Programming complexity

Many measures of software complexity have been proposed. Many of these, although yielding a good representation of complexity, do not lend themselves to easy measurement. Some of the more commonly used metrics are

• McCabe's cyclomatic complexity metric
• Halsteads software science metrics
• Henry and Kafura introduced Software Structure Metrics Based on Information Flow in 1981[2] which measures complexity as a function of fan in and fan out. They define fan-in of a procedure as the number of local flows into that procedure plus the number of data structures from which that procedure retrieves information. Fan-out is defined as the number of local flows out of that procedure plus the number of data structures that the procedure updates. Local flows relate to data passed to and from procedures that call or are called by, the procedure in question. Henry and Kafura's complexity value is defined as "the procedure length multiplied by the square of fan-in multiplied by fan-out" (Length ×(fan-in × fan-out)²).
• A Metrics Suite for Object-Oriented Design[3] was introduced by Chidamber and Kemerer in 1994 focusing, as the title suggests, on metrics specifically for object-oriented code. They introduce six OO complexity metrics; weighted methods per class, coupling between object classes, response for a class, number of children, depth of inheritance tree and lack of cohesion of methods

There are several other metrics that can be used to measure programming complexity:

• Branching complexity (Sneed Metric)
• Data access complexity (Card Metric)
• Data complexity (Chapin Metric)
• Data flow complexity (Elshof Metric)
• Decisional complexity (McClure Metric)

Tesler's Law is an adage in human–computer interaction stating that every application has an inherent amount of complexity that cannot be removed or hidden.

Associated with, and dependent on the complexity of an existing program, is the complexity associated with changing the program. The complexity of a problem can be divided into two parts:[4]

1. Accidental complexity: Relates to difficulties a programmer faces due to the chosen software engineering tools. A better fitting set of tools or a more high-level programming language may reduce it. Accidental complexity is often also a consequence of the lack of using the domain to frame the form of the solution i.e. the code. One practice that can help in avoiding accidental complexity is domain-driven design.
2. Essential complexity: Is caused by the characteristics of the problem to be solved and cannot be reduced.

Chidamber and Kemerer[3] proposed a set of programing complexity metrics, widely used in many measurements and academic articles. They are WMC, CBO, RFC, NOC, DIT, and LCOM, described below:

• WMC - weighted methods per class
  • ${\displaystyle WMC=\sum _{i=1}^{n}c_{i}}$
  • n is the number of methods on the class
  • ${\displaystyle c_{i}}$is the complexity of the method
• CBO - coupling between object classes
  • number of other class which is coupled (using or being used)
• RFC - response for a class
  • ${\displaystyle RFC=|RS|}$ where
  • ${\displaystyle RS=\{M\}\cup _{all\ i}\{R_{i}\}}$
  • ${\displaystyle R_{i}}$ is set of methods called by method i
  • ${\displaystyle M}$ is the set of methods in the class
• NOC - number of children
  • sum of all classes that inherit this class or a descendant of it
• DIT - depth of inheritance tree
  • maximum depth of the inheritance tree for this class
• LCOM- lack of cohesion of methods
  • Measures the intersection of the attributes used in common by the class methods
  • ${\displaystyle LCOM={\begin{cases}|P|-|Q|,&{\text{if }}|P|>|Q|\\0,&{\text{otherwise }}\end{cases}}}$
  • Where ${\displaystyle P=\{(I_{i},I_{j})|I_{i}\cap I_{j}=\emptyset \}}$
  • And ${\displaystyle Q=\{(I_{i},I_{j})|I_{i}\cap I_{j}\neq \emptyset \}}$
  • With ${\displaystyle I_{i}}$ is the set of attributes (instance variables) accessed (read from or written to) by the ${\displaystyle i}$-th method of the class

• Software crisis (and subsequent programming paradigm solutions)
• Software metrics - quantitative measure of some property of a program.