Software Metrics 1

Definitions Measure quantitative indication of extent, amount, dimension, capacity, or size of some attribute of a product or process e.g., Number of Errors Metric quantitative measure of degree to which a system, component or process possesses a given attribute. e.g., Number of errors found per person hour

Why Measure Software? Determine the quality of the current product or process Predict qualities of a product/process Improve quality of a product/process

Motivation for Metrics Estimate the cost & schedule of future projects Evaluate the productivity impacts of new tools and techniques Establish productivity trends over time Improve software quality Forecast future staffing needs Anticipate and reduce future maintenance needs

Example Metrics Defect rates Error rates Measured by: Individual Component During development Errors should be categorized by origin, type and cost

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 activities Hardware, knowledge, people

Product vs. Process Process Metrics Product Metrics Insights of process paradigm, software engineering tasks, work products, or milestones Lead to long term process improvement Product Metrics Accesses the state of the project Track potential risks Uncover problem areas Adjust workflow or tasks Evaluate teams ability to control quality

Types of Measures Direct Measures (internal attributes) Cost Effort LOC Speed, Memory, … Indirect Measures (external attributes) Functionality Quality Complexity Efficiency Reliability Maintainability

Size-Oriented Metrics Size of the software produced LOC – Lines of Code KLOC – 1000 Lines of Code SLOC – Statement (Source) Lines of Code (NLOC – Non-Commented Lines of Code) Function Points Typical Measures Errors/KLOC Defects/KLOC Cost/LOC Documentation Pages/KLOC

LOC Metrics Easy to use Easy to compute Language and Programmer dependent Not a very good standard “Measuring software productivity by Lines of Code is like measuring progress on an airplane by how much it weighs.” -- Bill Gates

Lines of Code? What about whitespace? Comments? Consider: Copy (char *p, *q) { while (*p) *q++ = *p++; } Copy (char *p, *q) { while (*p) *q++ = *p++; }

Lines of Code: Language Matters http://www.comp.lancs.ac.uk/computing/research/cseg/DIGITAL-LIBRARY/Renaissance/ConsultancyReport s/D33_Planning.pdf SLOC per Function Point Assembly 320 C 150 Fortran 106 Pascal 91 LISP 64 Smalltalk 21

Lines of Code… …is a valid metric when Same Language Standard Formatting Code has been reviewed

Depth of Inheritance Tree DIT is the maximum length from a node to the root of the tree (base class) Assumptions The deeper a class in the hierarchy, the greater the number of methods it will probably inherit which makes it harder to predict its behavior Deeper trees involve greater design complexity since more classes and methods are involved Deeper classes in the tree have a greater potential for reusing inherited methods Assumptions 1 and 2 tell us that having a higher number for depth is bad. However assumption 3 indicates that a higher number for depth is good for potential code reuse.

Complexity Metrics LOC – a function of complexity Cyclomatic Complexity Cohesion and Coupling

Cyclomatic Complexity A measure of logical (structural) complexity Gives an upper bound on the number of tests necessary to execute every edge of the control graph Number of independent paths (branches - if, while for) through the procedure Cyclomatic Complexity Risk Evaluation 1-10 A simple module without much risk 11-20 A more complex module with moderate risk 21-50 A complex module of high risk 51 and greater An untestable module of very high risk

Calculating Cyclomatic Complexity = (1 + IFs + Loops + Cases) where IFs is the number of IF operators in the function Loops is the number of loops in the function Cases is the number of switch branches in the function (without default)

Cyclomatic Complexity Example public override void UpdateInput() { // Get the current gamepad state. KeyboardState currentState = Keyboard.GetState(PlayerIndex.One); Keys [] keysPressed = currentState.GetPressedKeys(); foreach (Keys key in keysPressed) if (!previousKeyboardState.IsKeyDown(key)) if (commands.ContainsKey((int)key)) commands[(int)key].Execute(); // Update previous gamepad state. previousKeyboardState = currentState; }

Cyclomatic Complexity Example (cont) public override UpdateInput () foreach if ! if commands[].Execute (); done = (1 + 2{Ifs} + 1{Loops} + 0{Cases}) = 4

Visual Studio Code Metrics Calculated from Source Code Maintainability Index Cyclomatic Complexity Depth of Inheritance Class Coupling Lines of Code

Maintainability Index The maintainability index gives an indication of how easy it should be to understand and modify the code. The index is 0 <= index <= 100 with lower numbers indicating code that may be more difficult to work with (maintain) Based upon several other values Cyclomatic complexity Lines of code Halstead Volume Computational complexity of algorithms, determined by the number of operands and operators used. Fewer of each leads to better maintainability

Cyclomatic Complexity To reduce the cyclomatic complexity you should consider refactoring to extract methods If a method has a high value due to a large set of switch cases you might consider refactoring the code to use a design pattern such as the Strategy pattern

Class Coupling Indicates the amount of coupling between types in your source code. The value is the number of other types that a class uses through Properties Fields Method parameters Return values If you see the class coupling warning there is a high likelihood that your code requires refactoring

Lines of Code LOC describes the amount of source code that exists in your project or solution If the value is high for an individual member, consider refactoring LOC is not the number of lines of C# code; actually based upon the number of lines of intermediate language (IL) code after building the solution The value includes some, but not all, automatically generated code

Visual Studio Code Metrics Demonstration

?

References