1
Software measurement
Jonathan I. Maletic
Department of Computer Science
Kent State University
2
Definitions
Measure - quantitative indication of extent, amount, dimension,
capacity, or size of some attribute of a product or process.
– Number of errors
Metric - quantitative measure of degree to which a system,
component or process possesses a given attribute. “A handle or
guess about a given attribute.”
– Number of errors found per person hours expended
3
Why Measure Software?
• Determine quality of the current product or process
• Predict qualities of a product/process
• Improve quality of a product/process
4
Example Metrics
• Defects rates
• Errors rates
• Measured by:
- individual
- module
- during development
• Errors should be categorized by origin, type, cost
5
Metric Classification
• Products
- Explicit results of software development activities
- Deliverables, documentation, by products
• Processes
- Activities related to production of software
• Resources
- Inputs into the software development activitie
- Hardware, knowledge, people
6
Product vs. Process
Process Metrics:
- Insights of process paradigm, software engineering
tasks, work product, or milestones
- Lead to long term process improvement
Product Metrics:
- Assesses the state of the project
- Track potential risks
- Uncover problem areas
- Adjust workflow or tasks
- Evaluate teams ability to control quality
7
Types of Measures
Direct Measures (internal attributes)
- Cost, effort, LOC, speed, memory
Indirect Measures (external attributes)
- Functionality, quality, complexity, efficiency, reliability,
maintainability
8
Size Oriented Metrics
• Size of the software produced
• Lines Of Code (LOC)
• 1000 Lines Of Code KLOC
• Effort measured in person months
• Errors/KLOC
• Defects/KLOC
• Cost/LOC
• Documentation Pages/KLOC
• LOC is programmer & language dependent
9
LOC Metrics
• Easy to use
• Easy to compute
• Can compute LOC of existing systems but cost and
requirements traceability may be lost
• Language & programmer dependent
10
Function Oriented Metrics
• Function Point Analysis [Albrecht ’79, ’83]
• International Function Point Users Group (IFPUG)
• Indirect measure
• Derived using empirical relationships based on countable
(direct) measures of the software system (domain and
requirements)
11
Compute Function Points
• FP = Total Count * [0.65 + 0.01*Sum(Fi)]
• Total count is all the counts times a weighting factor that is
determined for each organization via empirical data
• Fi (i=1 to 14) are complexity adjustment values
12
Complexity Metrics
• LOC - a function of complexity
• Language and programmer dependent
• Halstead’s Software Science (entropy measures)
– n1 - number of distinct operators
– n2 - number of distinct operands
– N1 - total number of operators
– N2 - total number of operands
13
Example
if (k < 2)
{
if (k > 3)
x = x*k;
}
• Distinct operators: if ( ) { } > < = * ;
• Distinct operands: k 2 3 x
• n1 = 10
• n2 = 4
• N1 = 13
• N2 = 7
14
Halstead’s Metrics
• Amenable to experimental verification [1970s]
• Length: N = N1 + N2
• Vocabulary: n = n1 + n2
• Estimated length: Ñ = n1 log2 n1 + n2 log2 n2
- Close estimate of length for well structured programs
• Purity ratio: PR = Ñ / N
15
Program Complexity
• Volume: V = N log2 n
- Number of bits to provide a unique designator for
each of the n items in the program vocabulary.
• Program effort: E=V/L
- L = V*/V
- V* is the volume of most compact design
implementation
- This is a good measure of program understandability
16
McCabe’s Complexity Measures
• McCabe’s metrics are based on a control flow representation
of the program.
• A program graph is used to depict control flow.
• Nodes represent processing tasks (one or more code
statements).
• Edges represent control flow between nodes.
17
Flow Graph Notation
Sequence
While
If-then-else
Repeat-until
18
Cyclomatic Complexity
• Set of independent paths through the graph (basis set)
• V(G) = E – N + 2
- E is the number of flow graph edges
- N is the number of nodes
• V(G) = P + 1
- P is the number of predicate nodes
19
Example
i = 0;
while (i<n-1) do
j = i + 1;
while (j<n) do
if A[i]<A[j] then
swap(A[i], A[j]);
end do;
i=i+1;
end do;
20
Flow Graph
21
Computing V(G)
• V(G) = 9 – 7 + 2 = 4
• V(G) = 3 + 1 = 4
• Basis Set
- 1, 7
- 1, 2, 6, 1, 7
- 1, 2, 3, 4, 5, 2, 6, 1, 7
- 1, 2, 3, 5, 2, 6, 1, 7
22
Meaning
• V(G) is the number of (enclosed) regions/areas of the
planar graph
• Number of regions increases with the number of decision
paths and loops.
• A quantitative measure of testing difficulty and an
indication of ultimate reliability
• Experimental data shows value of V(G) should be no
more then 10. Testing is very difficulty above this value.
23
McClure’s Complexity Metric
• Complexity = C + V
- C is the number of comparisons in a module
- V is the number of control variables referenced in
the module
• Similar to McCabe’s but with regard to control variables.
24
High level Design Metrics
• Structural Complexity
• Data Complexity
• System Complexity
• Card & Glass ’80
• Structural Complexity S(i) of a module i.
- S(i) = fout
2(i)
- Fan out is the number of modules immediately
subordinate (directly invoked).
25
Design Metrics
• Data Complexity D(i)
- D(i) = v(i) / [ fout(i) +1]
- v(i) is the number of inputs and outputs passed to
and from i.
• System Complexity C(i)
- C(i) = S(i) + D(i)
- As each increases the overall complexity of the
architecture increases.
26
System Complexity Metric
• Another metric:
- length(i) * [ fin(i) + fout(i)]2
- Length is LOC
- Fan in is the number of modules that invoke i.
• Graph based:
- Nodes + edges
- Modules + lines of control
- Depth of tree, arc to node ratio
27
Component Level Metrics
• Cohesion (internal interaction)
• Coupling (external interaction)
• Complexity of program flow
• Cohesion
28
Coupling
• Data and control flow
- di - input data parameters
- ci - input control parameters
- do - output data parameters
- co - output control parameters
• Global
- gd - global variables for data
- gc - global variables for control
• Environmental
- w - fan in number of modules called
- r - fan out number modules that call module
29
Metrics for Coupling
Mc = k/m, k =1
m = di + aci + do + bco + gd + cgc + w + r
a, b, c, k can be adjusted based on actual data
30
Quality Model
31
Metrics and Software Quality
FURPS
• Functionality - features of system
• Usability - aesthesis, documentation
• Reliability - frequency of failure, security
• Performance - speed, throughput
• Supportability - maintainability
32
Measures of Software Quality
• Correctness
- Defects/KLOC
- Defect is a verified lack of conformance to requirements
- Failures/hours of operation
• Maintainability
- Mean time to change
- Change request to new version (Analyze, design etc)
- Cost to correct
• Integrity
- Fault tolerance, security & threats
• Usability
- Training time, skill level necessary to use, Increase in productivity,
subjective questionnaire or controlled experiment
33
Metrics for the Object Oriented
• Chidamber & Kemerer ’94 TSE 20(6)
• Metrics specifically designed to address object oriented
software
• Class oriented metrics
• Direct measures
34
Class Size
• CS
- Total number of operations (inherited, private,
public)
- Number of attributes (inherited, private, public)
• May be an indication of too much responsibility for
a class.
35
Number of Operations Overridden
• NOO
• A large number for NOO indicates possible
problems with the design.
• Poor abstraction in inheritance hierarchy.
36
Number of Operations Added
• NOA
• The number of operations added by a subclass.
• As operations are added it is farther away from super
class.
• As depth increases NOA should decrease.
37
Specialization Index
• SI = [NOO * L] / Mtotal
• L is the level in class hierarchy.
• Mtotal is the total number of methods.
• Higher values indicate class in hierarchy that does
not conform to the abstraction.
38
Method Inheritance Factor
• Mi (Ci) is the number of methods inherited and not overridden
in Ci
• Ma (Ci) is the number of methods that can be invoked with Ci
• Md (Ci) is the number of methods declared in Ci
39
Method Inheritance Factor
• Ma (Ci) = Md (Ci) + Mi (Ci)
• All that can be invoked = new or overloaded + things inherited
• MIF is [0,1]
• MIF near 1 means little specialization
• MIF near 0 means large change
40
Coupling Factor
• is_client(x,y) = 1 if a relationship exists between the client
class and the server class. 0 otherwise.
• (TC2 – TC) is the total number of relationships possible
(Total Classes2 – diagonal).
• CF is [0,1] with 1 meaning high coupling.
41
Using Metrics
• The Process
- Select appropriate metrics for problem
- Utilized metrics on problem
- Assessment and feedback
• Formulate
• Collect
• Analysis
• Interpretation
• Feedback
42
Úkoly
• Pro svůj projekt navrhněte (vyberte) 3 různé metriky a
okomentujte jejich význam.