References of Process_Models

@InProceedings{	  aebi:re-engineering,
  author	= {Daniel Aebi},
  title		= {Re-Engineering, Migration and Multi-Use of business Data},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {},
  class		= {Reengineering_in_General, Process_Models}
}

@Article{	  ahrens.prywes:transition,
  author	= {J. D. Ahrens and N. S. Prywes},
  title		= {Transition to a Legacy- and Reuse-Based Software Life
		  Cycle},
  journal	= {IEEE Computer},
  pages		= {27-36},
  year		= {1995},
  month		= oct,
  class		= {Reengineering_in_General, Process_Models}
}

@InProceedings{	  antonini.benedusi.ea:maintenance,
  author	= {P. Antonini and P. Benedusi and G. Cantone and Aniello
		  Cimitile},
  title		= {Maintenance and Reverse Engineering: Low Level Design
		  Documents Production and Improvement},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1987},
  year		= {1987},
  pages		= {91-100},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Process_Models_for_Reverse_Design}
}

@Article{	  basili:viewing,
  title		= {Viewing maintenance as reuse oriented software
		  development},
  author	= {V. Basili},
  journal	= {{IEEE} Software},
  volume	= {7},
  number	= {1},
  pages		= {19--25},
  year		= {1990},
  note		= { In this paper the maintenance process is incorporated in
		  the life-cycle perspective geared towards the reusability
		  of the various components},
  class		= {Reengineering_in_General, Process_Models,
		  Software_Reverse_Engineering, Re-Use}
}

@Article{	  belady.lehman:model,
  author	= {L. A. Belady and M. M. Lehman},
  title		= {A model of large program development},
  journal	= {IBM Systems Journal},
  year		= {1976},
  volume	= {15},
  pages		= {225-252},
  class		= {Reengineering_in_General, Process_Models }
}

@Article{	  benedusi.cimitile.ea:reverse*1,
  author	= {P. Benedusi and A. Cimitile and U. {De~Carlini}},
  title		= {Reverse Engineering Processes, Design Document Production,
		  and Structure Charts},
  journal	= {The Journal of Systems and Software},
  year		= {1992},
  month		= {November},
  volume	= {19(3)},
  pages		= {225-24},
  abstract	= {},
  class		= {Reengineering_in_General, Process_Models }
}

@InProceedings{	  benedusi.cimitile.ea:reverse*2,
  author	= {P. Benedusi and A. Cimitile and U. {De~Carlini}},
  title		= {A Reverse Engineering Methodology to Reconstruct
		  Hierarchical Data Flow Diagrams for Software Maintenance},
  booktitle	= {Proceedings of the IEEE Conference on Software
		  Maintenance},
  year		= {October 1989},
  pages		= {180-189},
  abstract	= {},
  class		= {Reengineering_in_General, Process_Models}
}

@Article{	  bergland:guided,
  author	= {G. D. Bergland},
  title		= {A guided tour of program design methodologies},
  journal	= {Computer},
  year		= {October 1981},
  pages		= {18-37},
  volume	= {14(10)},
  abstract	= {},
  class		= {Reengineering_in_General, Process_Models }
}

@Article{	  boehm:spiral,
  author	= {Barry W. Boehm},
  title		= {A Spiral Model of Software Development and Enhancement},
  journal	= {Computer},
  year		= {May 1988},
  pages		= {61-72},
  abstract	= {Seminal paper on the spiral model, which advocates a
		  series of prototypes and risk analysis steps.},
  class		= {Reengineering_in_General, Process_Models }
}

@TechReport{	  botsford.caldiera.ea:1992,
  key		= {Botsford et. al, 1992},
  author	= {J.E. Botsford and G. Caldiera and G.E. Kaiser and M.I.
		  Kellner and N.H. Madhavji},
  title		= {The 1992 Report on The Process Reuse Study (PRS) in CAS},
  institution	= {IBM Canada Ltd. Laboratory, Centre for Advanced Studies},
  year		= {1992},
  number	= {TR 74.106},
  address	= {895 Don Mills Road, North York, Ontario, Canada M3C 1W3},
  month		= nov,
  class		= {Reengineering_in_General, Process_Models}
}

@Article{	  britcher.craig:using*1,
  author	= {Robert N. Britcher and James J. Craig},
  year		= {May 1986},
  journal	= {IEEE Software},
  pages		= {16-24},
  title		= {Using Modern Design Practices to Upgrade Aging Software
		  Systems},
  volume	= {3(3)},
  abstract	= {},
  class		= {Reengineering_in_General, Process_Models }
}

@Article{	  butler.mccabe:clinical,
  author	= {Charles W. Butler and Thomas J. McCabe},
  title		= {A Clinical Approach to Reverse and Reengineering},
  journal	= {Reverse Engineering Newsletter},
  year		= {1992},
  pages		= {Rev-1 -- Rev-4},
  month		= jan,
  inhalt	= {Ma\3nahmen, um 'alternde' Systeme aufrecht zu erhalten (in
		  Anlehnung an die Gesundheitsvorsorge): - periodische
		  Untersuchung (je älter je häufiger) - Metriken erheben und
		  festhalten - falls sich die Werte verschlechtern,
		  korrigierende Ma\3nahmen einleiten: * Diagnose *
		  Gegenma\3nahmen ermitteln * Abwägung von Risiken/Kosten und
		  Nutzen
		  
		  Mögliche Metriken: - McCabes cyclomatic complexity V -
		  McCabes essential complexity EV
		  
		  auch zur Erkennung von Redundanz (gleiche V/EV von
		  Programmen => gleiche Funktionalität) und Wiederverwendung
		  (gleich V/EV von Program Description Language PDL und
		  existierendem Programm => gleiche Funktionalität) },
  class		= {Reengineering_in_General, Process_Models}
}

@Article{	  canfora.cimitile.ea:reverse*2,
  title		= {A Reverse Engineering Process for Design Level Document
		  Production from ADA Code},
  author	= {G. Canfora and A. Cimitile and U. De Carlini},
  journal	= {Information and Software Technology},
  volume	= {35},
  number	= {1},
  pages		= {23--34},
  year		= {1993},
  note		= { A reverse engineering process for producing design level
		  documents by static analysis of ADA code is described. This
		  is achieved via concurrent data flow diagrams describing
		  the task structure and the data flow between tasks.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Process_Models_for_Reverse_Design}
}

@InProceedings{	  colbrook.smythe.ea:data,
  author	= {A. Colbrook and C. Smythe and A. Darlison},
  title		= {Data Abstraction in a Software Re-engineering Reference
		  Model},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {2-11},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {The process of software re-engineering must incorporate
		  techniques for manipulating software which is imperative,
		  declarative or functional in nature. This generality needs
		  a mechanism for deriving the original requirements of the
		  underlying data structures contained within the source code
		  itself. In this paper a reference model is proposed from
		  which it is possible to derive the necessary techniques
		  required to implement such a mechanism. The reference model
		  is programming language independent and as such is well
		  suited to representing the general re-engineering
		  process.},
  class		= {Reengineering_in_General, Process_Models}
}

@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{	  desclaux.ribault:macs,
  author	= {Christine Desclaux and Michel Ribault},
  title		= {MACS: Maintenance Assistence Capability for Software
		  Maintenance},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1991},
  year		= {1991},
  pages		= {2-11},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {MACS goal is to offer a customizable software maintenance
		  assistance system. Its main concern is to help the
		  maintainer in gaining a deep understanding of existing or
		  in-progress applications, of the factual data (Change
		  Management World and Abstraction Recovery World) and the
		  design decisions rationale (Reasoning World), the mapping
		  of domain to programming components (Interconnection
		  World). Moreover this broad reverse-engineering approach is
		  enhanced by impact analysis techniques to better perceive
		  the interaction between components. The MACS supervisor
		  proposes a set of maintenance process models to guide the
		  maintainer through the MACS worlds. Knowledge Base and
		  Expert-System techniques are used in conjunction with
		  Software Engineering techniques, which makes MACS a KADME,
		  Knowledge Assistance for Development and Maintenance
		  Environment. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Reengineering_in_General, Process_Models}
}

@InProceedings{	  heineman.kaiser:incremental,
  author	= {George T. Heineman and Gail E. Kaiser},
  title		= {Incremental Process Support for Code Reengineering},
  pages		= {282-290},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Reengineering a large code base can be a monumental task,
		  and the situation becomes even worse if the code is
		  concomitantly being modified. Since January 1992, the
		  authors have been using the MARVEL process centered
		  environment (PCE) for all of their software development and
		  are currently using it to develop the OZ PCE (MARVEL's
		  successor). Towards this effort, the authors are
		  reengineering OZ's code base to isolate the process engine,
		  transaction manager, and object management system as
		  separate components that can be used in arbitrary systems.
		  In this paper, the authors show how a PCE can assist teams
		  of users in carrying out code reengineering while allowing
		  them to continue their normal code development. The key
		  features to this approach are its incremental nature and
		  the ability of the PCE to automate most of the tasks
		  necessary to maintain the consistency of the code base.},
  class		= {Reengineering_in_General, Process_Models}
}

@TechReport{	  kamper.rugaber:reverse,
  author	= {Kit Kamper and Spencer Rugaber},
  title		= {A Reverse Engineering Methodology for Data Processing
		  Applications},
  number	= {GIT-SERC-90/02},
  institution	= {Software Engineering Center Georgia Institute of
		  Technology, Atlanta, GA},
  year		= {1990},
  month		= mar,
  note		= {Figures are missing},
  abstract	= {Reverse engineering produces a high-level representation
		  of a software system from a low-level one. This paper
		  describes a methodology for reverse engineering that
		  constructs an architectural design for a system from its
		  source code and related documentation. The methodology
		  makes use of several techniques normally used during the
		  forward software development process as well as a new
		  technique called Synchronized Refinement. Synchronized
		  Refinement is a systematic approach to detecting design
		  decisions in source code and relating the detected
		  decisions to the functionality of the system. Examples are
		  given demonstrating the application of the methodology to
		  the reverse engineering of a production software system.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/synchronized.ps}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Process_Models_for_Reverse_Design,
		  Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design}
}

@InProceedings{	  kutscha.henning.ea:task,
  author	= {Sebastian Kutscha and Klaus Henning and Horst
		  Kesselmeier},
  title		= {The Task Artifact Cycle: A Conceptual Approach to
		  Maintenance and Re-engineering},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {We present a model - the so-called task artifact cycle -
		  which integrates the development of a system being in use
		  into the software lifecycle. The basic assumption of the
		  model is, that the actual use of a system may considerably
		  differ from the original design. This has to be taken into
		  consideration in maintenance and reengineering. In
		  particular, the monitoring of this development process is
		  an important basis for maintainability. },
  class		= {Reengineering_in_General, Process_Models}
}

@InProceedings{	  kölsch.wallrath:process,
  author	= {Ulrike Kölsch and Mechtild Wallrath},
  title		= {A Process Model for Controlling and Performing
		  Re-engineering Tasks},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {In this paper we present a process model for controlling
		  and performing re-engineering tasks. This process model is
		  based on a re-engineering methodology, that regards the
		  legacy system from the data-oriented perspective and aims
		  for decomposing and transforming it into an object-oriented
		  system along semantic units.
		  
		  The transformation from procedural to object-oriented
		  systems requires to deal with system models at different
		  abstraction levels which must be matched to each other. The
		  object identification and the match are controlled and
		  performed by two processes - the microprocess and the
		  macroprocess. In order to find and process information with
		  respect to an abstract object, the macroprocess initiates
		  and coordinates a set of microprocesses that perform
		  re-engineering tasks with respect to a secluded functional
		  and structural part of the IS. },
  class		= {Reengineering_in_General, Process_Models}
}

@InProceedings{	  liu.chen.ea:design,
  author	= {Xiaodong Liu and Zhiqiang Chen and Hongji Yang and Hussein
		  Zedan and William. C. Chu},
  title		= {A Design Framework for System Re-engineering},
  booktitle	= {Proceedings of Joint Asia Pacific Software Engineering
		  Conference and International Computer Science Conference},
  publisher	= {IEEE Computer Society},
  year		= {1997},
  address	= {Hong Kong},
  month		= {December},
  abstract	= { We discuss the current situation of formal methods and
		  their use in the re-engineering of computing systems,
		  especially real time systems. Based on the analysis result,
		  a solution which uses a consistent 4-sector Wide Spectrum
		  Language (WSL) is proposed, which presently includes the
		  general architecture and work flow, the structure of
		  Object-Action Model, the syntax and semantics of ObTAM
		  (Object Oriented Temporal Agent Model) and TGCL (Timed
		  Guarded Command Language). A small case study shows an
		  optimistic future of our WSL technique. Further research
		  will aim to build the complete semantic kernel of the WSL
		  and its associated algebraic laws, including transformation
		  rules and abstraction rules. },
  keywords	= {formal methods, re-engineering, wide spectrum language,
		  real-time systems, object orientation, Interval Temporal
		  Logic},
  class		= {Reengineering_in_General Requirement_Tracability
		  Software_Reverse_Engineering Reverse_Specification
		  Process_Models }
}

@InProceedings{	  ornburn.rugaber:reverse,
  title		= {Reverse engineering: resolving conflicts between expected
		  and actual software designs},
  author	= {S. Ornburn and S. Rugaber},
  booktitle	= {\cite{SM92}},
  pages		= {32--40},
  year		= {1992},
  note		= { Experience report describing the application of the
		  Synchronized Refinement method ~\cite{ROL90} to a real-time
		  embedded system},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Process_Models_for_Reverse_Design}
}

@Article{	  sneed:planning,
  author	= {H. Sneed},
  title		= {Planning the Reengineering of Legacy Systems},
  journal	= {IEEE Software},
  year		= {1995},
  volume	= {12},
  number	= {1},
  pages		= {24-33},
  month		= {January},
  class		= {Reengineering_in_General, Process_Models, Management}
}

@PhDThesis{	  wong:reverse,
  author	= {Kenny Wong},
  title		= {The Reverse Engineering Notebook},
  school	= {University of Victoria},
  year		= {1999},
  abstract	= {Software must evolve over time or it becomes useless. Much
		  of software production today is involved not in creating
		  wholly new code from scratch but in maintaining and
		  building upon existing code. Much of this code resides in
		  old legacy software systems.
		  
		  Unfortunately, these systems are often poorly documented.
		  Typically, they become more complex and difficult to
		  understand over time. Thus, there is a need to better
		  understand existing software systems. An approach toward
		  this problem would be a first step toward easing changes
		  and extending the continuous evolution of these systems.
		  
		  This dissertation addresses the problem by enabling
		  continuous software understanding. There should be a base
		  of reverse engineering abstractions that are carried
		  forward during evolution.
		  
		  The proposed approach seeks to redocument existing software
		  structure, capture the analysis decisions made, and support
		  personal, customizable, and live perspectives of the
		  software in an online journal called the Reverse
		  Engineering Notebook.
		  
		  The premise that software reverse engineering be applied
		  continuously throughout the lifetime of the software has
		  major tool design implications. Thus, tool integration,
		  process, and adoption are key issues for the Notebook. In
		  particular, data integration requirements, control
		  integration via pervasive scripting, presentation
		  integration through the management of views, user roles,
		  methodology, end user needs, and goal-directed framework
		  for the Notebook are described.
		  
		  A major theme of the dissertation is learning from the
		  successes and failures of studies involving tool
		  integration and reverse engineering technologies. Case
		  studies and user experiments helped to evaluate various
		  aspects of the Notebook approach and provide feedback into
		  software understanding tool requirements.
		  
		  },
  keywords	= {reverse engineering, program understanding, tool
		  requirements},
  class		= {Interoperability Reengineering_in_General Using_graphs
		  Reverse_Engineering_Tools Rig Process_Models
		  Software_Reverse_Engineering
		  Intermediate_Representations_of_Source_Code Experiences }
}

@InProceedings{	  yang.liu.ea:tackling,
  author	= {Hongji Yang and Xiaodong Liu and Hussein Zedan},
  title		= {Tackling the Abstraction Problem for Reverse Engineering
		  in a System Re-engineering Approach},
  booktitle	= {proceedings of the IEEE Conference on Software Maintenance
		  (ICSM'98)},
  publisher	= {IEEE Computer Society},
  year		= {1998},
  address	= {Washington D.C., USA},
  month		= {November},
  abstract	= {It is widely accepted that reverse engineering has three
		  components: restructuring, comprehension and production of
		  formal specification. In this paper, we advocate that the
		  three components could be achieved in a {\bf systematic}
		  approach by successfully applying a series of sound rules.
		  
		  The key approach to comprehension and the production of
		  formal specification is a notion of abstraction.
		  Abstraction is often interpreted as the act of hiding
		  irrelevant details. What constitute as relevant details is
		  often left open to different interpretations.
		  
		  A unified approach for reverse engineering is described
		  within which the notion of abstraction is classified and
		  precisely defined. Abstraction rules are given and applied
		  to various small examples. },
  keywords	= {reverse engineering, re-engineering, wide spectrum
		  language, abstraction, object oriented, Interval Temporal
		  Logic. },
  class		= {Reengineering_in_General Software_Reverse_Engineering
		  Reverse_Specification Formal_Methods Reverse_Design
		  Process_Models }
}