Coding Phase / Metrics McCall's Quality Factors

1. Coding Guidelines: Coding guidelines are a set of rules and best practices that define
how code should be written within a project or organization. These guidelines help ensure
consistency, readability, maintainability, and overall quality of the codebase. They cover
various aspects of coding such as naming conventions, indentation, comments, error
handling, and more. Following coding guidelines promotes code reusability, collaboration,
and makes it easier for developers to understand and maintain each other's code.

2. Code Documentation: Code documentation involves adding explanatory comments and

descriptions within the source code to provide insights into the code's purpose, behavior,
and usage. Documentation helps developers understand the codebase, its modules,
functions, and classes. It also assists in API design and usage, making it easier for other
developers to integrate and use the code. Good documentation helps with code
maintenance, debugging, and facilitates knowledge transfer between team members.

3. Structured Programming: Structured programming is a programming paradigm that

emphasizes the use of structured control flow constructs to improve code readability and
maintainability. It advocates for breaking down a program into smaller, manageable units
such as functions or modules. Structured programming discourages the use of unstructured
control flow statements like GOTO and instead promotes the use of control structures like
loops and conditional statements. By organizing code into logical structures, structured
programming improves code clarity, reduces complexity, and makes it easier to reason about
and maintain.

4. Code Inspection: Code inspection, also known as code review or peer review, is a
process where developers review each other's code to identify bugs, improve code quality,
and ensure adherence to coding guidelines and best practices. Code inspections can be
formal or informal, involving manual examination of the code for issues such as logic errors,
poor design choices, performance bottlenecks, security vulnerabilities, and adherence to
coding standards. Code inspections provide an opportunity for knowledge sharing, learning,
and improving the overall quality of the codebase.

Overall, coding guidelines, code documentation, structured programming, and code

inspection are essential practices in software development. They contribute to producing
maintainable, high-quality code and promote collaboration and efficiency within development
teams.

Metrics in software development refer to quantitative measures used to assess various

aspects of software projects, processes, and products. They provide valuable insights into
the project's progress, quality, and efficiency. Here's an overview of metrics, their objectives,
and two types of metrics: size-oriented (LOC-based) and function-oriented (FP-based)
metrics.

1. Objectives of Metrics:
- Measure progress: Metrics help track progress by quantifying the completion of tasks,
milestones, or project phases.

Harshit 9801907094
 Coding Phase / Metrics McCall's Quality Factors

- Assess quality: Metrics provide indicators of the quality of software products, identifying
defects, code complexity, and adherence to coding standards.
- Improve efficiency: Metrics highlight areas for improvement, helping teams identify
bottlenecks, optimize processes, and enhance productivity.
- Aid decision-making: Metrics enable data-driven decision-making by providing objective
information about project status, risks, and resource allocation.
- Benchmarking: Metrics allow comparisons with previous projects, industry standards, or
best practices to identify areas of improvement or success.

2. Size-oriented Metrics (LOC-based):

Size-oriented metrics focus on measuring the size or volume of software code. The most
common size-oriented metric is Lines of Code (LOC). It counts the number of lines in the
source code. Size-oriented metrics aim to assess productivity, effort, and maintainability of
the codebase. However, LOC-based metrics have limitations as they do not consider code
complexity or functionality.

Examples of size-oriented metrics:

- Lines of Code (LOC): Measures the number of lines in the source code.
- Source Lines of Code (SLOC): Similar to LOC, but excludes comments and blank lines.

3. Function-oriented Metrics (FP-based):

Function-oriented metrics measure the functionality or business value provided by the
software. Function Points (FP) is a widely used function-oriented metric that considers the
complexity and functionality of the software rather than just its size. It quantifies the software
based on user requirements, assessing the inputs, outputs, inquiries, files, and external
interfaces.

- Function Points (FP): A more advanced metric that quantifies the functionality provided by
the software based on user requirements.

Function Points are calculated based on the following components:

- External Inputs (EI): User inputs that affect the application's processing.
- External Outputs (EO): Data sent out from the application to the user or other systems.
- External Inquiries (EQ): User inquiries that result in data retrieval.
- Internal Logical Files (ILF): Logical groups of data maintained within the application.
- External Interface Files (EIF): Data referenced by the application but maintained by other
applications.

FP-based metrics provide a more comprehensive view of software functionality and are often
used for estimating effort, productivity, and project planning.

Overall, metrics play a vital role in software development by providing objective

measurements for progress, quality, efficiency, and decision-making. Size-oriented metrics
like LOC and function-oriented metrics like FP help evaluate different aspects of software
projects and products, focusing on code size or functionality, respectively.

Harshit 9801907094
 Coding Phase / Metrics McCall's Quality Factors

McCall's Quality Factors, also known as McCall's Software Quality Model, is a framework
developed by John McCall in 1977 to evaluate software quality. It defines various factors that
contribute to software quality and provides a structured approach for assessing and
measuring those factors. The McCall's Quality Factors model consists of three major
categories, each containing several subfactors:

1. Product Operation:
- Correctness: The degree to which the software meets the specified requirements and
produces the desired results.
- Reliability: The ability of the software to perform its intended functions without failure over a
specified period.
- Efficiency: The utilization of system resources, such as memory, processor, and time, in
relation to the software's performance.
- Integrity: The security and protection of data, preventing unauthorized access, modification,
or loss.
- Usability: The ease of use and intuitiveness of the software for its intended users.

2. Product Revision:
- Maintainability: The ease with which the software can be modified, enhanced, or repaired
to meet changing requirements or fix defects.
- Flexibility: The ability of the software to adapt and support new functionalities or
technologies without significant modifications.
- Testability: The ease of testing the software to ensure its quality, reliability, and correctness.
- Portability: The ability of the software to run on different platforms or environments with
minimal modifications.
- Reusability: The extent to which the software components can be reused in other
applications or projects.

3. Product Transition:
- Portability: The ease of transferring the software from one environment to another,
including hardware, software, and data.
- Interoperability: The ability of the software to work and communicate effectively with other
systems or components.
- Maintainability: The ease of maintaining the software during its life cycle, including
documentation, support, and updates.
- Transferability: The ease with which the software can be transferred from one user or
organization to another.

The McCall's Quality Factors model provides a comprehensive view of software quality,
considering not only functional aspects but also non-functional attributes such as reliability,
maintainability, and usability. By evaluating these factors, organizations can identify areas for
improvement, prioritize quality goals, and make informed decisions throughout the software
development lifecycle.

It's worth noting that the McCall's model is one of several software quality models, and
newer models have emerged over time to adapt to the changing landscape of software
development. However, McCall's model remains influential and provides a solid foundation
for understanding and evaluating software quality.

Harshit 9801907094