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.
Similar content being viewed by others
References
Abe, J., K. Sakamura, and H. Aiso (1979), An Analysis of Software Project Failure, IEEE Computer Society Press, New York, NY.
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.
Allen, F. and J. Cooke (1976), “A Program Data Flow Analysis Procedure,” Communications of the ACM 19,3, 137–147.
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.
Bail, W.G. and M.V. Zelkowitz (1978), Program Complexity Using Hierarchical Abstract Computers, AFIPS Press, College Park, MD.
Bailey, C. and W. Dingee (1981), “A Software Study Using Halstead Metrics,” ACM SIGMETRICS Performance Evaluation Review 10,1, 189–197.
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.
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.
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.
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.
Basili, V.R. and B.T. Perricone (1984), “Software Errors and Complexity: An Empirical Investigation,” Communications of the ACM 27,1, 42–52.
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.
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.
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.
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.
Booch, G. (1986), “Object Oriented Development,” IEEE Transactions on Software Engineering SE-12,2, 211–221.
Bowen, J.B. (1979), “A Survey of Standards and Proposed Metrics for a Software Quality Testing,” Computer 12,8, 37–41.
Bunge, M. (1979), Treatise on Basic Philosophy: Ontology II: The World of Systems, Reidel, Boston, MA.
Card, D.N. and W.W. Agresti (1987), “Resolving the Software Science Anomaly,” Journal of Systems and Software 7,1, 29–35.
Card, D.N. and W.W. Agresti (1988), “Measuring Software Design Complexity,” Journal of Systems and Software 8,3, 185–198.
Card, D.N. and R.L. Glass (1990), Measuring Software Design Quality, Prentice-Hall, Englewood Cliffs, NJ.
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.
Chapin, N. (1979), A Measure of Software Complexity, AFIPS Press, College Park, MD.
Chen, E.T. (1978), “Program Complexity and Programmer Productivity,” IEEE Transactions on Software Engineering SE-4,3, 187–194.
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.
Christensen, K., G.P. Fitsos, and C.P. Smith (1981), “A Perspective on Software Science,” IBM Systems Journal 20,4, 372–387.
Cook, M.L. (1982), “Software Metrics: An Introduction and Annotated Bibliography,” Software Engineering Notes 7,2, 41–60.
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.
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.
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.
Dunsmore, H.E. (1984), “Software Metrics: An Overview of an Evolving Methodology,” Information Processing and Management 20,1–2, 183–192.
Elshoff, J.L. and M. Marcotty (1978), “On the Use of Cyclomatic Number to Measure Program Complexity,” ACM SIGPLAN Notices 13,12, 29–40.
Fairley, R.E. (1985), Software Engineering Concepts, McGraw-Hill, New York, NY.
Fenton, N.E. (1992), Software Metrics — A Rigorous Approach, Chapman and Hall, London, England.
Fitzsimmons, A. and T. Love (1978), “A Review and Evaluation of Software Science,” ACM Computing Surveys 10,3, 3–18.
Gilb, T. (1985), Software Metrics, Studentliteratur, Lund, Sweden.
Gill, G.K. and C.F. Kemerer (1991), “Cyclomatic Complexity Density and Software Maintenance,” IEEE Transactions on Software Engineering SE-17,12, 1284–1288.
Gordon, R.D. (1979), “Measuring Improvements in Software Clarity,” IEEE Transactions on Software Engineering SE-5,2, 79–90.
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.
Grady, R.B. (1994), “Successfully Applying Software Metrics”, Computer 27,9, 18.
Grady, R.B. and D.L. Caswell (1987), Software Metrics: Establishing a Company-Wide Program, Prentice-Hall, Englewood Cliffs, NJ.
Grier, S. (1981), “A Tool that Detects Plagiarism in Pascal Programs,” ACM SIGCSE Bulletin 13,1, 1–10.
Halstead, M. (1975), “A Method of Programming Measurement and Estimation,” In Proceedings of ACM Conference, ACM, New York, NY, pp. 222–224.
Halstead, M. (1977), Elements of Software Science, Elsevier, New York, NY.
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.
Hansen, W.J. (1978), “Measurement of Program Complexity by the Pair (Cyclomatic Number, Operator Count),” ACM SIGPLAN Notices 13,3, 29–33.
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.
Henry, S. and D. Kafura (1984), “The Evaluation of Software Systems' Structure Using Quantitative Software Metrics,” Software Practice and Experience 14,6, 561–573.
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.
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.
Ince, D.C. (1990), “Software Metrics: An Introduction,” Information and Software Technology 32,4, 297–303.
Ince, D.C. (1991), “Software Metrics in Software Engineering and Artificial Intelligence,” International Journal Software Engineering and Knowledge 1,4, 463–476.
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.
Jones, T.C. (1978), “Measuring Programming Quality and Productivity,” IBM Systems Journal 17,1, 43–50.
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.
Kafura, D. and S. Henry (1981), “Software Quality Metrics Based on Interconnectivity,” Journal of Systems and Software 2,2, 121–131.
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.
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.
Kitchenham, B.A. (1990), Software Metrics, Elsevier, London, UK.
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.
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.
Li, H.F. and W.K. Chung (1987), “An Empirical Study of Software Metrics,” IEEE Transactions of Software Engineering SE-13,6, 697–708.
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.
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.
Lipow, M. (1982), “Number of Faults per Line of Code,” IEEE Transactions on Software Engineering SE-8,4, 437–439.
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.
McCabe, T. (1976), “A Complexity Measure,” IEEE Transactions on Software Engineering SE-2,4, 308–320.
McCabe, T.J. and C.W. Butler (1989), “Design Complexity Measurement and Testing,” Communications of the ACM 32,12, 1415–1425.
McCarthy, J. (1962), Towards a Mathematical Science of Computation, North-Holland, Amsterdam.
McClure, C.L. (1978), A Model for Program Complexity Analysis, IEEE Computer Society Press, New York, NY.
Mendis, K.S. (1982), Quantifying Software Quality, ACM Press, New York, NY.
Mohanty, S.N. (1979), “Models and Measurements for Quality Assessment of Software,” ACM Computing Surveys 11,1, 251–275.
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.
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.
Myers, G.J. (1977), “An Extension to the Cyclomatic Measure of Program Complexity,” ACM SIGPLAN Notices 12,10, 61–64.
Myrvold, A. (1990), “Data Analysis for Software Metrics,” Journal of Software Systems 12,2, 271–275.
Navlakha, J.K. (1987), “A Survey of System Complexity Metrics,” Computer Journal 30,3, 233–238.
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.
Parnas, D.L. (1972), “On Criteria To Be Used in Decomposing Systems into Modules,” Communications of the ACM 15,12, 1053–1058.
Perlis, A., F. Sayward, and M. Shaw (1981), Software Metrics: An Analysis and Evaluation, MIT Press, Cambridge, MA.
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.
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.
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.
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.
Shepperd, M.J. (1988), “A Critique of Cyclomatic Complexity as a Software Metric,” Software Engineering Journal 3,2, 1–8.
Shepherd, M.J. (1990), “Design Metrics: An Empirical Analysis,” IEE/BCS Software Engineering Journal 5,1, 3–10.
Sunohara, T., A. Takano, K. Uehara, and T. Ohkawaka (1981), Program Complexity Measure for Software Development Management, IEEE Computer Society Press, New York, NY.
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.
Tai, K.C. (1980), “Program Testing Complexity and Test Criteria,” IEEE Transactions on Software Engineering SE-6,6, 531–538.
Troy, D.A. and S.H. Sweben (1981), “Measuring the Quality of Structured Designs,” The Journal of Systems and Software 2,6, 113–120.
Waguespack, L.J. and S. Badlani (1987), “Software Complexity Assessment: An Introduction and Annotated Bibliography,” ACM Software Engineering Notes 12,4, 52–71.
Walston, C.E. and C.P. Felix (1977), “A Method of Program Measurement and Estimation,” IBM Systems Journal 16,1, 54–73.
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.
Wand, Y. and R. Weber (1990), “An Ontological Model of an Information System,” IEEE Transactions on Software Engineering SE-16,11, 1282–1292.
Weyuker, E.J. (1988), “Evaluating Software Complexity Measures,” IEEE Transactions on Software Engineering SE-14,9, 1357–1365.
Woodfield, S.N. (1979), “An Experiment on Unit Increase in Program Complexity,” IEEE Transactions on Software Engineering SE-5,2, 76–79.
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.
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.
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.
Yourdon, E. and L.L. Constantine (1978), Structured Design, Yourdon Press, New York, NY.
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.
Zuse, H. (1991), Software Complexity, De Gruiter, Berlin, Germany.
Author information
Authors and Affiliations
Rights and permissions
About this article
Cite this article
Blundell, J.K., Hines, M.L. & Stach, J. The measurement of software design quality. Annals of Software Engineering 4, 235–255 (1997). https://doi.org/10.1023/A:1018914711050
Issue Date:
DOI: https://doi.org/10.1023/A:1018914711050