Advertisement

Annals of Software Engineering

, Volume 4, Issue 1, pp 235–255 | Cite as

The measurement of software design quality

  • James Kenneth Blundell
  • Mary Lou Hines
  • Jerrold Stach
Article

Abstract

Software quality involves the conformance of a software product to some predefined set of functional requirements at a specified level of quality. The software is considered valid when it conforms to these “quality factors” at some acceptable level. There are a large number of quality factors against which software may be validated. This paper discusses the development of traditional software metrics in relation to the anticipated structure of a software system. The taxonomy of a software system primarily relies upon the dissection of the software system into modules. Modular design is the cornerstone of quality software, and metrics that can predict an optimum modular structure are critical. By examining the theoretical bases on quality metrics, a base set of common quantitative metrics can be devised and mapped to quality metrics in which they reside. This paper surveys existing metrics and suggests the derivation of software design metrics from software quality factors. Measurable software attributes are identified and suggested as potential design metrics.

Keywords

Quality Metrics Software Quality Software Metrics Software Characteristic Code Metrics 
These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

References

  1. Abe, J., K. Sakamura, and H. Aiso (1979), An Analysis of Software Project Failure, IEEE Computer Society Press, New York, NY.Google Scholar
  2. Albrecht, A.J. and J.E. Gaffney (1983), “Software Function, Source Lines of Code and Development Effort Prediction: A Software Science Validation,” IEEE Transactions on Software Engineering SE-9,11, 639–647.CrossRefGoogle Scholar
  3. Allen, F. and J. Cooke (1976), “A Program Data Flow Analysis Procedure,” Communications of the ACM 19,3, 137–147.zbMATHCrossRefGoogle Scholar
  4. Andersson, T., K. Enholm, and A. Torn (1994), “A Length-Independent Measure of Software Complexity,” In Software Quality Management II, Vol. 1: Managing Quality Systems, M. Ross, C.A. Brebbia, G. Staples, and J. Stapleton, Eds., Computational Mechanics Publications, Boston, MA, pp. 149–157.Google Scholar
  5. Bail, W.G. and M.V. Zelkowitz (1978), Program Complexity Using Hierarchical Abstract Computers, AFIPS Press, College Park, MD.Google Scholar
  6. Bailey, C. and W. Dingee (1981), “A Software Study Using Halstead Metrics,” ACM SIGMETRICS Performance Evaluation Review 10,1, 189–197.CrossRefGoogle Scholar
  7. Baker, A.L. and S.H. Zweben (1979), “The Use of Software Science in Evaluating Modularity Concepts,” IEEE Transactions on Software Engineering SE-5,2, 110–120.CrossRefGoogle Scholar
  8. Baker, A.L. and S.H. Zweben (1980), “A Comparison of Measures of Control Flow Complexity,” IEEE Transactions on Software Engineering SE-6,11, 506–512.MathSciNetCrossRefGoogle Scholar
  9. Banker, D.D., S.M. Datar, and D. Zweig (1989), “Software Complexity and Maintainability,” In 10th International Conference on Information Systems, IEEE Computer Society Press, New York, NY, pp. 247–255.Google Scholar
  10. Basili, V.R. (1990), “Recent Advances in Software Measurement,” In Proceedings of the 12th IEEE International Conference on Software Engineering, IEEE Computer Society Press, New York, NY, pp. 44–51.CrossRefGoogle Scholar
  11. Basili, V.R. and B.T. Perricone (1984), “Software Errors and Complexity: An Empirical Investigation,” Communications of the ACM 27,1, 42–52.CrossRefGoogle Scholar
  12. Basili, V.R., R.W. Selby, and T.Y. Phillips (1983), “Metric Analysis and Data Validation Across FORTRAN Projects,” IEEE Transactions on Software Engineering SE-9,11, 652–663.CrossRefGoogle Scholar
  13. Beane, J., N. Giddings, and J. Silverman (1984), “Quantifying Software Designs,” In Proceedings of the 7th International Conference on Software Engineering, IEEE Computer Society Press, New York, NY, pp. 314–322.Google Scholar
  14. Boehm, B., J.R. Brown, and M. Lipow (1976), “Quantitative Evaluation of Software Quality,” In Proceedings of 2nd International Conference on Software Engineering, IEEE Computer Society Press, New York, NY, pp. 592–605.Google Scholar
  15. Bohm, C. and A. Jacopini (1966), “Flow Diagrams, Turing Machines and Languages With Only Two Formation Rules,” Communication of the ACM 9,5, 366–371.CrossRefGoogle Scholar
  16. Booch, G. (1986), “Object Oriented Development,” IEEE Transactions on Software Engineering SE-12,2, 211–221.Google Scholar
  17. Bowen, J.B. (1979), “A Survey of Standards and Proposed Metrics for a Software Quality Testing,” Computer 12,8, 37–41.CrossRefGoogle Scholar
  18. Bunge, M. (1979), Treatise on Basic Philosophy: Ontology II: The World of Systems, Reidel, Boston, MA.Google Scholar
  19. Card, D.N. and W.W. Agresti (1987), “Resolving the Software Science Anomaly,” Journal of Systems and Software 7,1, 29–35.CrossRefGoogle Scholar
  20. Card, D.N. and W.W. Agresti (1988), “Measuring Software Design Complexity,” Journal of Systems and Software 8,3, 185–198.CrossRefGoogle Scholar
  21. Card, D.N. and R.L. Glass (1990), Measuring Software Design Quality, Prentice-Hall, Englewood Cliffs, NJ.Google Scholar
  22. Cavano, J.P. and J.A. McCall (1978), “A Framework for the Measurement of Software Quality,” In Proceedings of Software Quality Assurance Workshop, IEEE Computer Society Press, New York, NY, pp. 133–139.Google Scholar
  23. Chapin, N. (1979), A Measure of Software Complexity, AFIPS Press, College Park, MD.Google Scholar
  24. Chen, E.T. (1978), “Program Complexity and Programmer Productivity,” IEEE Transactions on Software Engineering SE-4,3, 187–194.CrossRefGoogle Scholar
  25. Chidamber, S.R. and C.F. Kemerer (1991), “Towards a Metrics Suite for Oject Oriented Design,” In Proceedings of ACM Conference on Object-Oriented Programming, Systems, Languages, and Applications, ACM Press, New York, NY, pp. 197–211.Google Scholar
  26. Christensen, K., G.P. Fitsos, and C.P. Smith (1981), “A Perspective on Software Science,” IBM Systems Journal 20,4, 372–387.Google Scholar
  27. Cook, M.L. (1982), “Software Metrics: An Introduction and Annotated Bibliography,” Software Engineering Notes 7,2, 41–60.CrossRefGoogle Scholar
  28. Curtis, W., S.B. Sheppard, and P. Milliman (1979a), Third Time Charm: Stronger Prediction of Programmer Performance by Software Complexity Metrics, IEEE Computer Society Press, New York, NY.Google Scholar
  29. Curtis, W., S.B. Sheppard, P. Milliman, M.A. Borst, and T. Love (1979b), “Measuring the Psychological Complexity of Software Maintenance Tasks with the Halstead and McCabe Metrics,” IEEE Transactions on Software Engineering SE-5,2, 96–104.CrossRefGoogle Scholar
  30. Davis, J.S. and R.J. LeBlanc (1988), “A Study of the Applicability of Complexity Measures,” IEEE Transactions on Software Engineering SE-14,9, 1366–1372.CrossRefGoogle Scholar
  31. Dunsmore, H.E. (1984), “Software Metrics: An Overview of an Evolving Methodology,” Information Processing and Management 20,1–2, 183–192.CrossRefGoogle Scholar
  32. Elshoff, J.L. and M. Marcotty (1978), “On the Use of Cyclomatic Number to Measure Program Complexity,” ACM SIGPLAN Notices 13,12, 29–40.CrossRefGoogle Scholar
  33. Fairley, R.E. (1985), Software Engineering Concepts, McGraw-Hill, New York, NY.Google Scholar
  34. Fenton, N.E. (1992), Software Metrics — A Rigorous Approach, Chapman and Hall, London, England.Google Scholar
  35. Fitzsimmons, A. and T. Love (1978), “A Review and Evaluation of Software Science,” ACM Computing Surveys 10,3, 3–18.zbMATHCrossRefGoogle Scholar
  36. Gilb, T. (1985), Software Metrics, Studentliteratur, Lund, Sweden.Google Scholar
  37. Gill, G.K. and C.F. Kemerer (1991), “Cyclomatic Complexity Density and Software Maintenance,” IEEE Transactions on Software Engineering SE-17,12, 1284–1288.CrossRefGoogle Scholar
  38. Gordon, R.D. (1979), “Measuring Improvements in Software Clarity,” IEEE Transactions on Software Engineering SE-5,2, 79–90.CrossRefGoogle Scholar
  39. Gordon, R.D. and M.H. Halstead (1976), “An Experiment Comparing FORTRAN Programming Times with the Software Physics Hypothesis,” In Proceedings of AFIPS, College Park, MD, pp. 935–937.Google Scholar
  40. Grady, R.B. (1994), “Successfully Applying Software Metrics”, Computer 27,9, 18.CrossRefGoogle Scholar
  41. Grady, R.B. and D.L. Caswell (1987), Software Metrics: Establishing a Company-Wide Program, Prentice-Hall, Englewood Cliffs, NJ.Google Scholar
  42. Grier, S. (1981), “A Tool that Detects Plagiarism in Pascal Programs,” ACM SIGCSE Bulletin 13,1, 1–10.CrossRefGoogle Scholar
  43. Halstead, M. (1975), “A Method of Programming Measurement and Estimation,” In Proceedings of ACM Conference, ACM, New York, NY, pp. 222–224.Google Scholar
  44. Halstead, M. (1977), Elements of Software Science, Elsevier, New York, NY.zbMATHGoogle Scholar
  45. Hamer, P.G. and G.D. Frewin (1982), “M.H. Halstead's Software Science: A Critical Examination,” In Proceedings of IEEE 6th International Conference on Software Engineering, IEEE Computer Society Press, New York, NY, pp. 197–206.Google Scholar
  46. Hansen, W.J. (1978), “Measurement of Program Complexity by the Pair (Cyclomatic Number, Operator Count),” ACM SIGPLAN Notices 13,3, 29–33.CrossRefGoogle Scholar
  47. Henry, S.M. and D.G. Kafura (1981), “Software Structure Metrics Based on Information Flow,” IEEE Transactions on Software Engineering SE-7,5, 510–518.CrossRefGoogle Scholar
  48. Henry, S. and D. Kafura (1984), “The Evaluation of Software Systems' Structure Using Quantitative Software Metrics,” Software Practice and Experience 14,6, 561–573.CrossRefGoogle Scholar
  49. Hines, M. L. and A. Goerner (1995), “Software Quality: Attributes and Modalities,” In Software Quality Management III, Vol. 2, Measuring and Maintaining Quality, M. Ross, C.A. Brebbia, G. Staples, and J. Stapleton, Eds., Computational Mechanics Publications, Boston, MA, pp. 137–146.Google Scholar
  50. Hutchens, D.H. and V.R. Basili (1985), “System Structure Analysis: Clustering with Data Bindings,” IEEE Transactions on Software Engineering SE-11,8, 749–757.CrossRefGoogle Scholar
  51. Ince, D.C. (1990), “Software Metrics: An Introduction,” Information and Software Technology 32,4, 297–303.CrossRefGoogle Scholar
  52. Ince, D.C. (1991), “Software Metrics in Software Engineering and Artificial Intelligence,” International Journal Software Engineering and Knowledge 1,4, 463–476.CrossRefGoogle Scholar
  53. Jayaprakash, S., K.B. Lakshamanan, and P.K. Sinha (1987), “MEBOW: A Comprehensive Measure of Control Flow Complexity,” In Proceedings of COMPSAC'87, IEEE Computer Society Press, New York, NY, pp. 238–244.Google Scholar
  54. Jones, T.C. (1978), “Measuring Programming Quality and Productivity,” IBM Systems Journal 17,1, 43–50.Google Scholar
  55. Kafura, D. and J.T. Canning (1985), “A Validation of Software Metrics Using Many Metrics and Two Resources,” In Proceedings of 8th International Conference on Software Engineering, IEEE Computer Society Press, New York, NY, pp. 378–385.Google Scholar
  56. Kafura, D. and S. Henry (1981), “Software Quality Metrics Based on Interconnectivity,” Journal of Systems and Software 2,2, 121–131.CrossRefGoogle Scholar
  57. Kafura, D.G. and G.R. Reddy (1987), “The Use of Software Complexity Metrics in Software Maintenance,” IEEE Transactions of Software Engineering SE-13,3, 335–343.CrossRefGoogle Scholar
  58. Kearney, J.K., R.L. Sedlmeyer, W.B. Thompson, M.A Gray, and M.A. Adler (1986), “Software Complexity Measurement,” Communications of the ACM 29,11, 1044–1050.CrossRefGoogle Scholar
  59. Kitchenham, B.A. (1990), Software Metrics, Elsevier, London, UK.Google Scholar
  60. Kitchenham, B.A., L.M. Pickard, and S.J. Linkman (1990), “An Evaluation of Some Design Metrics,” IEEE/BCS Software Engineering Journal 5,1, 50–58.Google Scholar
  61. Lassez, J.L., D. van der Knijff, J. Shepherd, and C. Lassez (1981), “A Critical Examination of Software Science,” Journal of Systems and Software 2,2, 105–112.MathSciNetCrossRefGoogle Scholar
  62. Li, H.F. and W.K. Chung (1987), “An Empirical Study of Software Metrics,” IEEE Transactions of Software Engineering SE-13,6, 697–708.CrossRefGoogle Scholar
  63. Lieberherr, K., I. Holland, and A. Riel (1988), “Object Oriented Programming: An Objective Sense of Style,” In Proceedings of the ACM Conference on Object-Oriented Programming, Systems, Languages, and Applications, ACM Press, New York, NY, pp. 323–334.Google Scholar
  64. Lind, R.K. and K. Vairavan (1989), “An Experimental Investigation of Software Metrics and Their Relationship to Software Development Effort,” IEEE Transactions on Software Engineering 15,5, 649–653.CrossRefGoogle Scholar
  65. Lipow, M. (1982), “Number of Faults per Line of Code,” IEEE Transactions on Software Engineering SE-8,4, 437–439.CrossRefGoogle Scholar
  66. Lohse, J.B. and K. Zweben (1984), “Experimental Evaluation of Software Design Principles: An Investigation into the Effect of Module Coupling on System and Modifiability,” Journal of Systems and Software 4,4, 301–308.CrossRefGoogle Scholar
  67. McCabe, T. (1976), “A Complexity Measure,” IEEE Transactions on Software Engineering SE-2,4, 308–320.MathSciNetCrossRefGoogle Scholar
  68. McCabe, T.J. and C.W. Butler (1989), “Design Complexity Measurement and Testing,” Communications of the ACM 32,12, 1415–1425.CrossRefGoogle Scholar
  69. McCarthy, J. (1962), Towards a Mathematical Science of Computation, North-Holland, Amsterdam.Google Scholar
  70. McClure, C.L. (1978), A Model for Program Complexity Analysis, IEEE Computer Society Press, New York, NY.Google Scholar
  71. Mendis, K.S. (1982), Quantifying Software Quality, ACM Press, New York, NY.Google Scholar
  72. Mohanty, S.N. (1979), “Models and Measurements for Quality Assessment of Software,” ACM Computing Surveys 11,1, 251–275.zbMATHMathSciNetCrossRefGoogle Scholar
  73. Moreau, D.R. and W.D. Dominick (1989), “Object Oriented Graphical Information Systems: Research Plan and Evaluation Metrics,” Journal of Systems and Software 10,1, 23–28.CrossRefGoogle Scholar
  74. Munson, J.C. and T.M. Khoshgoftaar (1990), “The Relative Software Complexity Metric: A Validation Study,” In Proceedings of BCS/IEE Software Engineering '90 Conference, Computational Mechanics Publications, Southampton, UK, pp. 89–102.Google Scholar
  75. Myers, G.J. (1977), “An Extension to the Cyclomatic Measure of Program Complexity,” ACM SIGPLAN Notices 12,10, 61–64.CrossRefGoogle Scholar
  76. Myrvold, A. (1990), “Data Analysis for Software Metrics,” Journal of Software Systems 12,2, 271–275.MathSciNetCrossRefGoogle Scholar
  77. Navlakha, J.K. (1987), “A Survey of System Complexity Metrics,” Computer Journal 30,3, 233–238.CrossRefGoogle Scholar
  78. Oviedo, E.I. (1980), “Control Flow, Data Flow and Program Complexity,” In IEEE Computer Software and Applications Conference, IEEE Computer Society Press, New York, NY, pp. 146–152.Google Scholar
  79. Parnas, D.L. (1972), “On Criteria To Be Used in Decomposing Systems into Modules,” Communications of the ACM 15,12, 1053–1058.CrossRefGoogle Scholar
  80. Perlis, A., F. Sayward, and M. Shaw (1981), Software Metrics: An Analysis and Evaluation, MIT Press, Cambridge, MA.Google Scholar
  81. Pfleeger, S.L. and J.D. Palmer (1990), “Software Estimation for Object Oriented Systems,” In Proceedings of Fall International Function Point Users Group Conference, ACM, San Antonio, TX, pp. 181–196.Google Scholar
  82. Samson, W.B., D.G. Nevill, and P.I. Dugard (1987), “Predictive Software Metrics Based on a Formal Specification,” Information and Software Technology 29,5, 242–248.CrossRefGoogle Scholar
  83. Schneidewind, N.F. and H.M. Hoffman (1979), “An Experiment in Software Error Data Collection and Analysis,” IEEE Transactions on Software Engineering SE-5,3, 276–286.CrossRefGoogle Scholar
  84. Shen, V.Y., S.D. Conte, and H.E. Dunsmore (1983), “Software Science Revisited: A Critical Analysis Theory and Its Empirical Support,” IEEE Transactions on Software Engineering SE-9,2, 155–165.CrossRefGoogle Scholar
  85. Shepperd, M.J. (1988), “A Critique of Cyclomatic Complexity as a Software Metric,” Software Engineering Journal 3,2, 1–8.CrossRefGoogle Scholar
  86. Shepherd, M.J. (1990), “Design Metrics: An Empirical Analysis,” IEE/BCS Software Engineering Journal 5,1, 3–10.Google Scholar
  87. Sunohara, T., A. Takano, K. Uehara, and T. Ohkawaka (1981), Program Complexity Measure for Software Development Management, IEEE Computer Society Press, New York, NY.Google Scholar
  88. Szulewski, P., P. Bucher, S. DeWolf, and M. Whiteworth (1981), “The Measurement of Software Science Parameters in Software Design,” ACM SIGMETRICS Performance Evaluation Review 10,1, 89–94.CrossRefGoogle Scholar
  89. Tai, K.C. (1980), “Program Testing Complexity and Test Criteria,” IEEE Transactions on Software Engineering SE-6,6, 531–538.CrossRefGoogle Scholar
  90. Troy, D.A. and S.H. Sweben (1981), “Measuring the Quality of Structured Designs,” The Journal of Systems and Software 2,6, 113–120.CrossRefGoogle Scholar
  91. Waguespack, L.J. and S. Badlani (1987), “Software Complexity Assessment: An Introduction and Annotated Bibliography,” ACM Software Engineering Notes 12,4, 52–71.CrossRefGoogle Scholar
  92. Walston, C.E. and C.P. Felix (1977), “A Method of Program Measurement and Estimation,” IBM Systems Journal 16,1, 54–73.CrossRefGoogle Scholar
  93. Wand, Y. (1987), “A Proposal for a Formal Model of Objects,” In Research Directions in Object Oriented Programming, MIT Press, Cambridge, MA, pp. 537–559.Google Scholar
  94. Wand, Y. and R. Weber (1990), “An Ontological Model of an Information System,” IEEE Transactions on Software Engineering SE-16,11, 1282–1292.CrossRefGoogle Scholar
  95. Weyuker, E.J. (1988), “Evaluating Software Complexity Measures,” IEEE Transactions on Software Engineering SE-14,9, 1357–1365.MathSciNetCrossRefGoogle Scholar
  96. Woodfield, S.N. (1979), “An Experiment on Unit Increase in Program Complexity,” IEEE Transactions on Software Engineering SE-5,2, 76–79.CrossRefGoogle Scholar
  97. Woodfield, S.N., V.Y. Shen, and H.E. Dunsmore (1981), “A Study of Several Metrics for Programming Effort,” The Journal of Systems and Software 2,2, 79–103.CrossRefGoogle Scholar
  98. Woodward, M.R., M.A. Hennell, and D. Hedley (1979), “A Measure of Control Flow Complexity in Program Text,” IEEE Transactions on Software Engineering SE-5,1, 45–50.CrossRefGoogle Scholar
  99. Yin, B.H. and J.W. Winchester (1978), “The Establishment and Use of Measures to Evaluate the Quality of Software Designs,” Communications of the ACM 1,1, 15–25.Google Scholar
  100. Yourdon, E. and L.L. Constantine (1978), Structured Design, Yourdon Press, New York, NY.Google Scholar
  101. Zolnowski, J.C. and D.B. Simmons (1981), “Taking the Measure of Program Complexity,” In Proceedings of the National Computer Conference, IEEE Computer Society Press, New York, NY, 329–336.Google Scholar
  102. Zuse, H. (1991), Software Complexity, De Gruiter, Berlin, Germany.Google Scholar

Copyright information

© Kluwer Academic Publishers 1997

Authors and Affiliations

  • James Kenneth Blundell
    • 1
  • Mary Lou Hines
    • 1
  • Jerrold Stach
    • 1
  1. 1.Computer Science Telecommunications ProgramUniversity of Missouri–Kansas CityKansas CityUS E-mail:

Personalised recommendations