References of Metrics

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

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

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

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