References of Software_Evolution

@InProceedings{	  baker.eick:visualizing,
  author	= {M. J. Baker and S. G. Eick},
  title		= {Visualizing software systems},
  pages		= {59--70},
  booktitle	= {Proceedings of the 16th  International Conference on
		  Software Engineering },
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= may,
  abstract	= {There are many graphical techniques for visualizing
		  software. Unfortunately, the current techniques do not
		  scale to display large software systems and are largely
		  unused. The authors present a method for visualizing
		  statisistics associated with code that is devided
		  hierarchically into subsystems, directories, and files.
		  Using the authors' technique, the authors can display the
		  relative sizes of the components in the system, which
		  components are stable and which are changing, where the new
		  functionality is being added, and identify error-prone code
		  with many bug fixes. Using animation, the authors can
		  display the historical evolution of the code.},
  class		= {Software_Reverse_Engineering, Software_Evolution}
}

@InProceedings{	  debaud:dare,
  author	= {Jean-Marc DeBaud},
  title		= {DARE: Domain-Augmented ReEngineering},
  booktitle	= {Proceedings of the Fourth Working Conference on Reverse
		  Engineering},
  publisher	= {IEEE Computer Society Press Los Alamitos California},
  year		= {1997},
  editor	= {Ira Baxter and Alex Quilici and Chris Verhoef},
  abstract	= {We present in this article the principles of a
		  domain-augmented reengineering approach (DARE) as well as
		  our initial experience applying sections of it. The
		  principal characteristic of the DARE approach is its focus
		  upon the computational context of a software system i.e.
		  the business or scientific domain to which it relates. This
		  context information is used both to drive the program
		  understanding as well as for the program evolution phases
		  of reengineering. In DARE a domain model (concepts and
		  associated relationships) serves as the structure denoting
		  context and is used for two purposes. First a dictionary of
		  possible domain concept realizations is populated. Second a
		  set of mappings from the domain to an existing tool or
		  library related to the domain is defined. Reengineering
		  then proceeds as follows: First a legacy system is analyzed
		  and annotated with the dictionary of domain concept
		  realizations. Then these matched concepts are transitioned
		  to the tool or library using the predefined mapping set.
		  Program evolution can then take place at the level of the
		  tool or library. Using our initial experience we discuss
		  DARE present an analysis and suggest implications for
		  future work.},
  class		= {Software_Evolution Software_Reverse_Engineering
		  Model_Generating Reverse_Specification Reverse_Design
		  Domain_Analysis Process_Models_for_Reverse_Design
		  Knowledge-Based_Concept_Assignmen }
}

@InProceedings{	  krikhaar:reverse,
  author	= {R.L. Krikhaar},
  title		= {Reverse Architecting Approach for Complex Systems},
  booktitle	= {Proceedings of the IEEE International Conference on
		  Software Maintenance},
  publisher	= {IEEE Computer Society},
  year		= {1997},
  pages		= {p4-11},
  abstract	= {Philips is an electronics company which operates world
		  wide and participates in professional as well as consumer
		  markets. The architecture of many software intensive
		  systems are currently not optimally prepared for the
		  changing market. For example the variety of systems is
		  increasing because different users or user groups demand
		  slightly different variants of a system. Good understanding
		  of systems is required to be able to follow these changes.
		  During the last years we have analysed a number of systems
		  from which we have derived a general approach for reverse
		  architecting (RA). Our approach has proved to be applicable
		  for various complex systems in different domains. It
		  consists of a number RA steps. In this paper we describe
		  three RA steps and indicate some aspects of other RA steps.
		  The description is supplemented with three case studies of
		  complex systems. The complete set of RA steps is not fully
		  independent however it is not necessary to perform all RA
		  steps for each case. },
  keywords	= {Architecture improvement reverse architecting complex
		  software software architecture reverse engineering module
		  architecture },
  class		= {Software_Evolution Software_Reverse_Engineering }
}

@InProceedings{	  li.yang.ea:generating,
  author	= {Yang Li and Hongji Yang and William Chu},
  title		= {Generating Linkage between Source Code and Evolvable
		  Domain Knowledge for the Ease of Software Evolution},
  booktitle	= {Proceedings of IEEE International Symposium on Principles
		  of Software Evolution (ISPSE2000)},
  publisher	= {IEEE Computer Society Press},
  year		= {2000},
  editor	= {},
  chapter	= {},
  pages		= {},
  address	= {Kanazawa, Japan},
  month		= {Nov},
  url		= {},
  abstract	= {Business software systems unexceptably need to be evolved
		  to cater for new/changed requirement coming from market or
		  adapt to new operating environment. One of the most
		  significant problems in current software evolution practice
		  is that software maintainers usually find it quite
		  difficult to locate the program sections in source code
		  which need to be modified and to identify the extent to
		  which the changes in these program sections could affect
		  the rest of the software system. In this paper, we propose
		  a knowledge engineering based approach to solving this
		  problem. In particular, we match a software program with a
		  pre-defined domain knowledge base in the representation of
		  simplified semantic network we proposed in order to link
		  the source program with its domain level interpretation.
		  The domain knowledge base contains only important domain
		  knowledge where potential evolutions could occur, which
		  reduces the size of the knowledge base. Moreover, a domain
		  oriented program partitioning method is also proposed to
		  cut a program into self-contained modules with manageable
		  size. In these ways, the computational complexity involved
		  in generating the linkage is significantly reduced which
		  makes this approach applicable. An example shows that
		  software evolution can be easily carried out as the domain
		  knowledge it links with evolves. },
  keywords	= {software evolution, knowledge engineering, program
		  partitioning, evolvable domain knowledge, semantic
		  network},
  note		= {This paper gives engineering-oriented considerations to
		  link generation between domain knowledge and source code
		  prior to successful software evolution.},
  class		= {Software_Evolution Knowledge-Based_Concept_Assignment
		  Using_graphs Change_Impac
		  Cognitive_Processes_in_Human_Program_Understanding Metrics
		  Reverse_Design Re-Design System_Modularization
		  Recovery_of_Software_Architecture
		  Metric-Based_Methods_in_Reverse_Design Alteration
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning
		  Intermediate_Representations_of_Source_Code
		  Software_Reverse_Engineering }
}