References of Module_Cohesion

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