Software Measurement Metrics
Software Measurement Metrics
1. Size-Oriented Metrics
Size-oriented metrics focus on the size of the software system, typically measured in lines of code
(LOC), function points, or other metrics that reflect the scale or size of the software product. The two
common types are:
Lines of Code (LOC): This is a basic metric to count the number of lines in a source code file,
ignoring comments and blank lines. It helps in estimating the complexity and effort involved in
development. However, LOC can be misleading as it does not account for code quality,
complexity, or functionality.
Source Lines of Code (SLOC): A variation of LOC that counts only lines of executable code,
excluding comments and blank spaces.
The main limitation of size-oriented metrics is that they do not capture the functional value or behavior
of the software.
2. Function-Oriented Metrics
Function-oriented metrics aim to measure the functionality of the software from the user's perspective.
The most widely used function-oriented metric is Function Points (FP). Function points assess the
software based on its functional requirements, helping to estimate the complexity and size of the
software system without focusing on lines of code.
Function points provide a more consistent and reliable way to measure software size and complexity
since they focus on what the system is doing rather than how it is implemented.
Extended Function Points (EFP) are an enhancement to the basic Function Point metric. They
incorporate additional factors and consider not just the number of inputs, outputs, and files, but also
other characteristics that can affect the system’s complexity and functionality. These extensions can
include:
Technical Complexity Factor (TCF): Adjusts the function point count based on factors like
performance, usability, and security requirements.
Complexity Adjustments: Accounting for changes in the business rules or technical constraints
that can affect the system.
EFP metrics aim to provide a more comprehensive and refined measure of software complexity, making
them useful for larger, more complex systems.
Class 6 27th Feb,2025
4. Object-Oriented Metrics
Object-oriented metrics are used for measuring the complexity, quality, and size of object-oriented
software systems. These systems use objects, classes, inheritance, polymorphism, and other object-
oriented concepts that require different metrics than traditional function-oriented or size-oriented
metrics.
Coupling: Measures the degree of interdependence between classes. High coupling indicates
that classes are tightly connected, making the system harder to maintain.
Cohesion: Refers to how closely related the responsibilities of a class are. High cohesion means
that the methods and data within a class are closely related, which is desirable.
Depth of Inheritance Tree (DIT): This measures the maximum inheritance levels for a class.
Deeper inheritance trees can increase complexity.
Number of Children (NOC): This refers to the number of immediate subclasses of a class. A
higher NOC can indicate more complex behavior due to inheritance.
Response For a Class (RFC): The number of methods that can be potentially invoked in
response to a message sent to an object of a class. It reflects the complexity of the class in terms
of how many different methods can be invoked.
Weighted Methods per Class (WMC): A count of the number of methods within a class,
weighted by the complexity of each method. It helps in determining the class's complexity.
Object-oriented metrics help developers understand various aspects of object-oriented design, such as
modularity, reusability, and maintainability, by analyzing the structure and relationships between objects
and classes.
Summary
Size-Oriented Metrics (like LOC) focus on the physical size of the software but can be
misleading in terms of functionality.
Function-Oriented Metrics (like Function Points) focus on the functionality of the system,
providing a more accurate measure of software complexity and effort.
Extended Function Point Metrics enhance function points by considering additional factors
like technical complexity and business rules.
Object-Oriented Metrics focus on analyzing the complexity, design, and maintainability of
object-oriented systems through metrics like coupling, cohesion, and inheritance.
Each of these metrics serves a different purpose, and they can be used in combination to provide a
comprehensive view of a software system's size, functionality, and quality.