References of Metric-Based_Methods_in_Reverse_Design

@InProceedings{	  april.merlo.ea:reverse,
  author	= {A. April and E.Merlo and A.Abran},
  title		= {A Reverse Engineering Approach to Evaluate Function Point
		  Rules},
  booktitle	= {WCRE'97 Proceeding},
  publisher	= {IEEE},
  year		= {1997},
  abstract	= {Function Points are generally used for measuring software
		  functional size from a user perspective. This paper is
		  concerned with the problem of counting function points from
		  source code using the Function Point Analysis proposed by
		  the International Function point User Group (IFPUG) 1994
		  standards. This paper presents the Automated FP counting
		  scope and objective, the presentation of an existing
		  semi-formal model and the required extensions for the
		  definition of four IFPUG rules. Then we propose reverse
		  engineering techniques to address those four rules. },
  keywords	= {Automation of Function Point, Reverse Engineering,
		  Software Measurement, backfiring},
  class		= {Software_Reverse_Engineering Metrics Reverse_Design
		  Metric-Based_Methods_in_Reverse_Design }
}

@InProceedings{	  beane.giddings.ea:quantifying,
  author	= {J. Beane and N. Giddings and J. Silverman},
  title		= {Quantifying software designs},
  pages		= {314--323},
  booktitle	= {Proceedings of the 7th  International Conference on
		  Software Engineering },
  year		= {1984},
  publisher	= {IEEE Computer Society Press},
  month		= mar,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@Article{	  belady.evangelisti:system,
  title		= {System partitioning and its measure},
  author	= {L. Belady and C. Evangelisti},
  journal	= {Journal of Systems and Software},
  volume	= {2},
  pages		= {23--29},
  year		= {1981},
  note		= { A method to perform automatic clustering of data
		  structures and calls is described. A metric to quantify the
		  complexity of the resulting partitioning is given},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design,
		  Automated_Reverse_Design, System_Modularization}
}

@InProceedings{	  briand.morasca.ea:assessing,
  author	= {L. Briand and S. Morasca and V. Basili},
  title		= {"Assessing Software Maintainability at the end of
		  High-Level Design"},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  month		= sep,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@InProceedings{	  calliss.cornelius:potpurri,
  author	= {Frank W. Calliss and Barry J. Cornelius},
  title		= {Potpurri Module Detection},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {46-51},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {A potpourri module is a module that provides more than one
		  service to a program. This form of module violates the idea
		  of a module being considered as a ''responsibility
		  assignment''. The existence of this form of module
		  increases considerably the effort that a programmer has to
		  expend on a maintenance operation, and increases the
		  likelihood of an error being introduced to a program as a
		  result of maintenance work. Techniques are presented for
		  detecting potpourri modules that appear in programs written
		  in a language that contains a module construct (such as Ada
		  and Modula-2). Many of these techniques can be automated.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design,
		  Automated_Reverse_Design}
}

@Article{	  choi.scacchi:extracting,
  author	= {Song C. Choi and Walt Scacchi},
  title		= {Extracting and Restructuring the Design of Large Systems},
  journal	= {IEEE Software},
  year		= {1990},
  volume	= {7},
  number	= {1},
  pages		= {66-71},
  month		= jan,
  note		= { An algorithm is described that for a given initial design
		  description the system-reconstruction algorithm constructs
		  a hierarchy of the system's modules and subsystems},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design,
		  Automated_Reverse_Design}
}

@InProceedings{	  chu.patel:software,
  author	= {William C. Chu and Sukesh Patel},
  title		= {Software Restructuring by Enforcing Localization and
		  Information Hiding},
  pages		= {165-172},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {Imperative languages like C, Fortran, and Cobol do not
		  provide facilities for expressing system structure
		  information. Understanding, maintaining and reusing large
		  scale software systems implemented in these languages is
		  difficult and time consuming. In this paper the authors sho
		  how the semantic basis underlying modern system structure
		  constructs (supported in languages such as Ada and C++) can
		  be used to simplify the understanding of software written
		  in conventional imperative languages. The restructuring
		  technique analyzes the input source code system into a
		  hierarchical system struture that exploits information
		  hiding and localization properties. This hierarchical view
		  will help to accurately identify a component's dependencies
		  and visibility relationships with other system
		  sub-components. Besides obvious understandability and
		  maintainability benefits this form of restructure offers a
		  convenient framework for translating conventional languages
		  to languages that support modularity, abstract data types,
		  and hierarchical system structure.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design,
		  Automated_Reverse_Design}
}

@InProceedings{	  cimitile.di-lucca.ea:maintenance,
  author	= {Aniello Cimitile and Di Lucca, G. A. and P. Maresca},
  title		= {Maintenance and Intermodule Dependencies in Pascal
		  Environment},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {72-83},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {This paper outlines the important role that actual and,
		  mainly, potential intermodular dependencies play in the
		  maintenance phase of a software product.
		  
		  The authors discuss the problem with reference to Pascal
		  systems and they show how reverse engineering and static
		  code analysis enable the identification of the actual and
		  the potential intermodular data flow and relationships.
		  
		  Some constraints are proposed to prevent an uncontrollable
		  proliferation of data binding among modules and their
		  reciprocal calls. To achieve the consistency of the
		  programs respect to the adopted constraints, the
		  intermodular dependencies knowledge, as produced by reverse
		  engineering, is used to restructure both data and module
		  declarations also.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design,
		  Automated_Reverse_Design}
}

@InProceedings{	  dumke.kompf:came,
  author	= {Reiner R. Dumke and Gunnar Kompf},
  title		= {CAME Tools for an Efficient Software Maintenance},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {This paper describes the role of the metrics tools as
		  Computer Assisted Software Measurement and Evaluation
		  (CAME) tools in the software life cycle, especially in the
		  maintenance phase. The most CAME tools are designed for
		  code analysis and measurement. They are predestined to be
		  applied to the implementation and maintenance development
		  phases. But, more and more tools are developed for the
		  earlier phases of software development to estimate the
		  effort, complexity, and size of the software that will be
		  created. This paper will provide an overview of the present
		  situation on the area of the CAME tools and discuss their
		  efficient use in the software maintenance. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics}
}

@InProceedings{	  emerson:discriminant,
  author	= {T. Emerson},
  title		= {A Discriminant Metric for Module Cohesion},
  year		= {1984},
  publisher	= {IEEE Computer Society Press},
  month		= mar,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@InProceedings{	  harris.reubenstein.ea:reverse,
  author	= {David R. Harris and Howard B. Reubenstein and Alex S.
		  Yeh},
  title		= {Reverse Engineering to the Architectural Level},
  booktitle	= {Proceedings of the 17th  International Conference on
		  Software Engineering },
  year		= {1995},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  abstract	= {Recovery of higher level ''design'' information and the
		  ability to create dynamic, task adaptable software
		  documentation is crucial to supporting a number of program
		  understanding activities. This paper presents research that
		  demonstrates that reverse engineering technology can be
		  used to recover software architecture representations fo
		  source code.
		  
		  The authors have developed a framework that integrates
		  reverse engineering technology and architectural style
		  representations. Using the framework, analysts can recover
		  custom, dynamic documentation to fit a variety of software
		  analysis requirements. Our goal is to establish coherent
		  abstractions appropriate for helping analysts to understand
		  large software systems. The authors discuss a code coverage
		  metric useful for assessing the degree of program
		  understanding achieved.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design,
		  Automated_Reverse_Design}
}

@Article{	  harrison.magel.ea:applying,
  author	= {W. Harrison and K. Magel and R. Kluczny and A. DeKock},
  title		= {Applying Software Complexity Metrics to Program
		  Maintenance},
  journal	= {IEEE Computer},
  year		= {1982},
  volume	= {15},
  number	= {9},
  month		= sep,
  pages		= {65-79},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Maintenance_Metrics}
}

@Article{	  jorgensen:experience,
  title		= {Experience with the accuracy of software maintenance task
		  effort prediction models},
  author	= {M. Jorgensen},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {674--681},
  volume	= {21},
  number	= {8},
  year		= {1995},
  note		= {Eleven software maintenance effort prediction models are
		  discussed},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Maintenance_Metrics}
}

@InProceedings{	  khan:design,
  key		= {Khan, 1994},
  author	= {Javed I. Khan},
  title		= {Design Extraction by Adiabatic Multi-Perspective
		  Abstraction},
  pages		= {191-200},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Design extraction of an unfamiliar system is a complex
		  cognitive task. This paper presents an approach that can
		  help human expert in exploring a large and complex code
		  information space of an unfamiliar software. It provides
		  her/him a platform to access the code information with
		  flexible, fine and delicate control over volume and
		  composition of the accessed information sub-space. The
		  proposed approach integrates two forms of abstraction.
		  First, it helps to comprehend complexity of the code
		  information space by allowing explorer to investigate the
		  system from numerous (combinatorial) coherent perspectives.
		  In the second level, it helps to overcome scale of the
		  information space by allowing explorer to compress or
		  expand any composition of its sub-spaces. This new
		  approach, named as adiabatic multi-perspective (AMP)
		  approach to program abstraction, is founded on a
		  symmetrical dual hierarchical (SDH) organization of code
		  information space and a novel formalism for abstract
		  dependency analysis (ADA), which is also one of the first
		  formalism to perform complete program dependency analysis
		  on abstract program models.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design,
		  Automated_Reverse_Design}
}

@InProceedings{	  lakhotia:rule-based,
  author	= {Arun Lakhotia},
  title		= {Rule-based approach to computing module cohesion},
  pages		= {35--44},
  booktitle	= {Proceedings of the 15th  International Conference on
		  Software Engineering },
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  abstract	= {Stevens, Myers, and Constantine introduced the notion of
		  cohesion, an ordinal scale of seven levels that describes
		  the degree to which the actions performed by a module
		  contribute to a unified function. The provided rules,
		  termed as 'associative principles' to examine the
		  relationships between 'processing elements' of a module and
		  designate a cohesion level to it. Stevens et. al., however,
		  did not give a precise definition for the term 'processing
		  element', thereby leaving it open for interpretations.
		  
		  This paper interprets the 'output variables' (not
		  statements) of a module as its processing elements. Stevens
		  et. al.'s associative principles are transformed to relate
		  the output variables based on their 'data' and 'control
		  dependence' relationships. What results is a rule-based
		  approach to computing cohesion. Experimental results show
		  that, but for temporal cohesion, the cohesion associated to
		  a module under our reinterpretation and that due to the
		  original definitions are identical for all examples.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@InProceedings{	  li.yang.ea:clarity,
  author	= {Yang Li and Hongji Yang and William Chu},
  title		= {Clarity Guided Belief Revision for Domain Knowledge
		  Recovery in Legacy Systems},
  booktitle	= {Proceedings of the 12th International Conference on
		  Software Engineering and Knowledge Engineering (SEKE2000)},
  publisher	= {Knowledge System Institute},
  year		= {2000},
  editor	= {Daniel E. Cooke and Joseph E. Urban},
  chapter	= {},
  pages		= {248-255},
  address	= {Chicago, USA},
  month		= {June},
  url		= {},
  abstract	= {Program understanding is the process of acquiring
		  knowledge from a computer program. Although research work
		  utilising knowledge engineering techniques has been
		  undertaken in this field, it is our observation that a
		  thorough application of AI methodology has not been
		  sufficiently explored. In this paper, we present a clarity
		  guided belief revision approach to domain knowledge
		  recovery in legacy software systems. Novel solutions are
		  given to three key AI issues in the context of domain
		  knowledge recovery from source code: knowledge
		  representation, where concrete semantic network is
		  separated from abstract semantic network to better
		  accommodate uncertainty reasoning and propagation;
		  uncertainty reasoning, which borrows ideas from
		  confirmation theory and recasts them in the context of
		  semantic network reasoning; heuristic search, which is
		  designed on the principle of programming psychology. Our
		  approach is light-weighted. It can be used stand-alone or
		  as a complement to traditional heavy-weighted domain
		  knowledge recovery methods. },
  keywords	= {program understanding, knowledge recovery, semantic
		  network, belief revision, heuristic search, programming
		  psychology},
  note		= {This paper describes our innovative work where
		  psychology-based methodology was brought into the area of
		  Articial Intelligence and was applied in the field of
		  domain knowledge recovery from source code.},
  class		= {Knowledge-Based_Concept_Assignment System_Modularizatio
		  Model_Generating Reverse_Specification Metrics
		  Reverse_Design Domain_Analysis
		  Metric-Based_Methods_in_Reverse_Design
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning
		  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 }
}

@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{	  li.yang:fusing,
  author	= {Yang Li and Hongji Yang},
  title		= {Fusing Ambiguous Domain Knowledge Slices in a Reverse
		  Engineering Process},
  booktitle	= {Proceedings of the 7th Asia-Pacific Software Engineering
		  Conference (APSEC2000)},
  publisher	= {IEEE Computer Society Press},
  year		= {2000},
  editor	= {},
  chapter	= {},
  pages		= {},
  address	= {Singapore},
  month		= {Dec},
  url		= {},
  abstract	= {Recovering domain knowledge from legacy code plays an
		  important role in the new information technology era, which
		  can be of help for program understanding, system evolution
		  and software reuse. Traditional methods for domain
		  knowledge recovery from source code did not sufficiently
		  address the issue of ambiguity handling, in particular, the
		  propagation of ambiguity among multiple domain knowledge
		  slices recovered from source code in software reverse
		  engineering process. In this paper, we present a novel
		  approach to recovering unambiguous domain knowledge from
		  legacy code, where isolated ambiguous domain knowledge
		  slices are ``fused'' together in an iterative ambiguity
		  propagation process and hence the disambiguity of these
		  recovered knowledge slices is increased. },
  keywords	= {reverse engineering, domain knowledge recovery,
		  co-operative behaviour, belief revision},
  note		= {This is the first of this kind of work which deals with
		  the ambiguity involved in recovering large-scale domain
		  knowledge from source code.},
  class		= {Automated_Reverse_Design
		  Knowledge-Based_Concept_Assignment Using_graphs
		  Model_Generating Reverse_Specification
		  Cognitive_Processes_in_Human_Program_Understanding
		  Reverse_Design Domain_Analysis
		  Recovery_of_Software_Architectur
		  Metric-Based_Methods_in_Reverse_Design
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning
		  Intermediate_Representations_of_Source_Code
		  Software_Reverse_Engineering }
}

@InProceedings{	  muller.uhl:composing*1,
  author	= {Hausi A. M\"uller and James S. Uhl},
  title		= {Composing Subsystem Structures Using (K,2)-Partite
		  Graphs},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {12-19},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Subsystem composition is the process of constructing
		  composite software components out of building blocks such
		  as variables, procedures, modules, and sybsystems.
		  Hierarchical subsystem structures are formed by imposing
		  equivalence relations on the resource-flow graphs of the
		  source code. Composition algorithms often use a single
		  equivalence relation (e.g., connection strength or data
		  binding measure) to form automatically tree-shaped
		  composite structures.
		  
		  This paper describes a clustering method that uses
		  equivalence relations for identifying subsystem structures.
		  The relations are intended to embody the software
		  engineering principles that concern module interactions
		  such as low coupling, high strength, small interfaces, and
		  few interfaces. The resulting compositions are
		  (k,2)-partite graphs (a class of layered graphs) rather
		  than strict tree hierarchies. The method is supported by
		  our interactive graph editor.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design,
		  Automated_Reverse_Design,
		  Software_Reverse_Engineering_Tools, Rigi}
}

@InProceedings{	  oman.hagemeister:metrics,
  author	= {Paul Oman and Jack Hagemeister},
  title		= {Metrics for Assessing a Software System's
		  Maintainability},
  pages		= {337-344},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {The factors of software that determine or influence
		  maintainability can be organized into a hierarchical
		  structure of measurable attributes. For each of these
		  attributes we show a metric definition consistent with the
		  published definitions of the software characteristic being
		  measured. The result is a tree structure of maintainability
		  metrics which can be used for purposes of evaluating the
		  relative maintainability of the software system. In this
		  paper the authors define metrics for measuring the
		  maintainability of a target software system and discuss how
		  those metrics can be combined into a single index of
		  maintainability.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Maintenance_Metrics}
}

@InProceedings{	  ott.bieman:effects,
  author	= {Linda M. Ott and James M. Bieman},
  title		= {Effects of Software Changes on Module Cohesion},
  pages		= {345-353},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {We use program slices to model module cohesion. For our
		  purpose, a slice is a projection of program text that
		  includes only the data tokens relevant to one output. We
		  define six cohesion metrics in terms of these slices, and
		  evaluate the effects of classes of module changes on these
		  metrics. We find that the effects on cohesion metrics are
		  notably more predictable when the changes result from
		  adding code rather than from moving code. In general, the
		  effects that software changes have on the cohesion metrics
		  match our intuition.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@InProceedings{	  ott.thuss:relationship,
  author	= {Linda M. Ott and J. J. Thuss},
  title		= {The Relationship Between Slices and Module Cohesion},
  booktitle	= {Proceedings of the 11th  International Conference on
		  Software Engineering },
  pages		= {198--204},
  month		= may,
  year		= {1989},
  abstract	= {The authors examine the relationship between the data flow
		  in a module and its level of cohesion using a processing
		  element flow graph (PFG). Based on these PFGs, they regroup
		  the original seven levels of cohesion into four
		  classifications. Slice profiles are then defined by
		  generating slices for all output variables of a module. A
		  relationship is then shown between these slice profiles and
		  the PFG used to indicate levels of cohesion. It is
		  suggested that these slice profiles can be used to
		  determine more easily the cohesiveness of a module.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@InProceedings{	  patel.chu.ea:measure,
  author	= {Sukesh Patel and William C. Chu and R. Baxter},
  title		= {A Measure for Composite Module Cohesion},
  booktitle	= {Proceedings of the 14th  International Conference on
		  Software Engineering },
  pages		= {38--48},
  month		= may,
  year		= {1992},
  abstract	= {An important software design activity is the decomposition
		  of complex systems into conceptually independent modules
		  that cooperate to achieve a desired result. This
		  modularization represents a significant software
		  engineering activity that continues to receive considerable
		  research attention. The authors illustrate how software may
		  be modularized by automatically determining the
		  cohesiveness of modules in the system. Module cohesion is
		  defined to be a quality attribute that seeks to measure the
		  singleness of purpose of a module. They propose a metric
		  that measures the cohesion of individual subprograms of a
		  software system as related to each other. This metric is
		  illustrated with detailed examples and is supported with
		  empirical evidence supporting the viability of the
		  measure.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@Article{	  paulson.wand:automated,
  author	= {D. Paulson and Y. Wand},
  title		= {An Automated Approach to Information Systems
		  Decomposition},
  journal	= {IEEE Transactions on Software Engineering},
  volume	= {18},
  number	= {3},
  pages		= {174-189},
  year		= {1992},
  month		= mar,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design,
		  Automated_Reverse_Design}
}

@Article{	  pickard.carter:field,
  title		= {A Field Study of the Relationship of Information Flow and
		  Maintainability of COBOL Programs},
  author	= {M.M. Pickard and B.D. Carter},
  journal	= {Information and Software Technology},
  volume	= {37},
  number	= {4},
  pages		= {195--202},
  year		= {1995},
  note		= { The results of a field study of the relationship of
		  information flow to the maintainability of COBOL modules in
		  a data processing environment are presented. There is a
		  significant correlation between maintainability and
		  information flow and with (information flow) metrics it is
		  possible to identify poorly maintained modules},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Maintenance_Metrics}
}

@InProceedings{	  schwanke:intelligent,
  author	= {R. W. Schwanke},
  title		= {An Intelligent Tool for Re-engineering Software
		  Modularity},
  booktitle	= {Proceedings of the 13th  International Conference on
		  Software Engineering },
  pages		= {83--92},
  month		= may,
  year		= {1991},
  abstract	= {The author describes a software tool that provides
		  heuristic modularization advice for improving existing
		  code. A heuristic design similarity measure is defined,
		  based on the Parnas' information hiding principle. The
		  measure supports two services: clustering, which identifies
		  groups of related procedures, and maverick analysis, which
		  identifies individual procedures that appear to be in the
		  wrong module. The tool has already provided useful advice
		  in several real programming projects. The tool will soon
		  incorporate an automatic tuning method, which allows the
		  tool to learn from its mistakes, adapting its advice to the
		  architect's preferences. A preliminary experiment
		  demonstrates that the automatically tuned similarity
		  function can assign procedures to modules very
		  accurately.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design,
		  Automated_Reverse_Design}
}

@InProceedings{	  sneed.kaposi:study,
  author	= {Harry M. Sneed and Agnes Kaposi},
  title		= {A study on the Effect of Reengineering on
		  Maintainability},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {91-99},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {The report presented here on the effect of reengineering
		  upon software maintainablility stems from a laboratory
		  experiment conducted within the METKIT research project of
		  the European ESPRIT program for the study and promotion of
		  the use of metrics in Software-Engineering. The experiment
		  was conducted as a case study in measuring software
		  complexity and maintainablility. However, the results also
		  serve to assess the benefits of reengineering old programs.
		  Maintainability is defined as the effort to perform
		  maintenance tasks, the impact domain of the maintenance
		  actions and the error rate caused by those actions.
		  Complexity is defined as a combination of code, data, data
		  flow, structure, and control flow metrics. From the data
		  collected it demonstrates that reengineering can decrease
		  complexity and increase maintainability, but that
		  restructuring has only a minor effect on maintainability.},
  class		= {Reengineering_in_General, Experiences,
		  Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Maintenance_Metrics}
}

@InProceedings{	  stavely.becker.ea:collection,
  author	= {A. M. Stavely and D. C. Becker and S. P. Orr and G. B.
		  Titus},
  title		= {A collection of software tools for analyzing designs of
		  concurrent software systems},
  pages		= {111--118},
  booktitle	= {Proceedings of the 8th  International Conference on
		  Software Engineering },
  year		= {1985},
  publisher	= {IEEE Computer Society Press},
  month		= aug,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design,
		  Automated_Reverse_Design}
}

@Article{	  withrow:error,
  title		= {Error density and size in {Ada} software},
  author	= {C. Withrow},
  journal	= {{IEEE} Software},
  volume	= {7},
  number	= {1},
  pages		= {26--30},
  year		= {1990},
  note		= { In this paper we can find an empirical study of the
		  relation between error density and the length of an Ada
		  module. The results show that there is an optimal length
		  and that shorter modules and larger ones contain more
		  errors. For reverse engineering such metrics can give an
		  indication for the status of the software},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics}
}