References of Recovery_of_Software_Architecture

@InProceedings{	  allen.garlan:formalizing,
  author	= {R. Allen and D. Garlan},
  title		= {Formalizing architectural connection},
  pages		= {71--80},
  booktitle	= {Proceedings of the 16th  International Conference on
		  Software Engineering },
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Recovery_of_Software_Architecture}
}

@Unpublished{	  antoniol.fiutem.ea:program,
  author	= {G. Antoniol and R. Fiutem and G. Lutteri and P. Tonella
		  and S. Zanfei},
  title		= {Program Understanding and Maintenance with the CANTO
		  environment},
  year		= {1998},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis,
		  Recovery_of_Software_Architecture}
}

@InProceedings{	  beach:connecting,
  author	= {B. W. Beach},
  title		= {Connecting Software Components with Declarative Glue},
  booktitle	= {ICSE~14: Proceedings of the 14th International Conference
		  on Software Engineering, {\rm (Melbourne, Australia; May
		  1992)}},
  pages		= {120-137},
  year		= {May 1992},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Recovery_of_Software_Architecture }
}

@InProceedings{	  kazman.bass.ea:saam,
  author	= {R. Kazman and L. Bass and G. Abowd and M. Webb},
  title		= {{SAAM}: {A} method for analyzing the properties of
		  software architectures},
  pages		= {81--90},
  booktitle	= {Proceedings of the 16th  International Conference on
		  Software Engineering },
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= may,
  class		= {Software_Reverse_Engineering,
		  Recovery_of_Software_Architecture}
}

@InProceedings{	  kazman.burth:assessing,
  author	= {Rick Kazman and Marcus Burth},
  title		= {Assessing Architectural Complexity},
  year		= {1998},
  publisher	= {IEEE Computer Society},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Recovery_of_Software_Architecture}
}

@Article{	  l.r.ea:relational,
  author	= {Feijs L. and Krikhaar R. and Ommering R. van},
  title		= {A Relational Approach to Support Software Architecture
		  Analysis},
  journal	= {Software - Practice and Experience},
  year		= {1998},
  volume	= {28},
  number	= {4},
  pages		= {371-400},
  month		= {April},
  abstract	= {This paper reports on our experience with a relational
		  approach to support the analysis of existing software
		  architectures. The analysis options provide for
		  visualisation and view calculation. The approach has been
		  applied for reverse engineering. It is also possible to
		  check concrete designs against architecture-related rules.
		  The paper surveys the theory, the tools and some of the
		  applications developed so far.},
  keywords	= {software structuring; reverse engineering; relational
		  algebra; software architecture},
  class		= {Software_Reverse_Engineering Reverse_Design
		  Recovery_of_Software_Architecture }
}

@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 }
}

@InProceedings{	  li.yang.ea:towards,
  author	= {Yang Li and Hongji Yang and William Chu},
  title		= {Towards Building a Smarter Domain Knowledge Recovery
		  Assistant},
  booktitle	= {Proceedings of the 24th IEEE Annual Computer Software and
		  Applications Conference (COMPSAC2000)},
  publisher	= {IEEE Computer Society Press},
  year		= {2000},
  editor	= {},
  chapter	= {},
  pages		= {},
  address	= {},
  month		= {Oct},
  url		= {},
  abstract	= {Legacy systems need to be ``salvaged'' to prolong their
		  life circle. One way for such a salvation is to recover and
		  maintain domain knowledge embedded in legacy code. It is
		  our observation that existing methods or tools for domain
		  knowledge recovery from source code did not provide
		  maintainers with sufficient assistance to reduce the size
		  of analysable program sections, identify program sections
		  having intensive domain knowledge and maintain the belief
		  of a network of domain knowledge extracted from source code
		  which can accommodate change of belief coming from a user.
		  In this paper, we introduce techniques which can provide
		  software maintainers with smart assistance for the
		  above-mentioned three issues. },
  keywords	= {program partitioning, program readability metric, belief
		  network, domain knowledge recovery},
  note		= {We incorpate human psychology knowledge with the design of
		  a domain knowledge recovery tool.},
  class		= {Automated_Reverse_Design
		  Knowledge-Based_Concept_Assignment Reverse_Engineering_Tool
		  Model_Generating Reverse_Specification
		  Cognitive_Processes_in_Human_Program_Understanding Metrics
		  Reverse_Design System_Modularization Domain_Analysis
		  Recovery_of_Software_Architecture
		  Metric-Based_Methods_in_Reverse_Design
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning
		  Software_Reverse_Engineering }
}

@InProceedings{	  lindig.snelting:assessing,
  author	= {C. Lindig and G. Snelting},
  title		= {Assessing modular structure of legacy code based on
		  mathematical concept analysis},
  booktitle	= {Proceedings of the 19th  International Conference on
		  Software Engineering },
  publisher	= {IEEE Computer Society Press},
  year		= {1997},
  key		= {Concept Analysis},
  class		= {Software_Reverse_Engineering,
		  Recovery_of_Software_Architecture }
}

@InProceedings{	  tzerpos.holt:orphan,
  author	= {Vassilios Tzerpos and R.C. Holt},
  title		= {The Orphan Adoption problem in Architecture Maintenance},
  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	= {A lot of research time has been devoted to finding a
		  solution to the problem of automatic clustering especially
		  in the field of Reverse Engineering where decomposing a
		  legacy system to subsystems could be the key to
		  understanding it. Maintaining the obtained structure as a
		  system evolves however is a problem that has attracted much
		  less attention. In this paper we present the Orphan
		  Adoption problem in architecture maintenance and propose an
		  algorithm to solve it. We also present case studies that
		  validate the usefulness of our algorithm. },
  class		= {Software_Reverse_Engineering Reverse_Design
		  Recovery_of_Software_Architecture }
}

@Article{	  wong.tilley.ea:structural,
  author	= {Kenny Wong and Scott Tilley and Haus Mueller and
		  Margaret-Anne Storey},
  title		= {Structural Redocumentation: A Case Study},
  journal	= {IEEE Software},
  year		= {1995},
  volume	= {12},
  number	= {1},
  pages		= {46-54},
  month		= {January},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Recovery_of_Software_Architecture}
}