Software Architecture

Software architecture refers to the high-level structure of a software system, defining its components,
their relationships, and the principles guiding its design and evolution. It serves as a blueprint for the
system, ensuring that it meets functional and non-functional requirements
Software engineering is a disciplined approach to the development, operation, and maintenance of
software systems. It encompasses a systematic, organized, and quantifiable process for designing,
building, testing, deploying, and maintaining software applications, ensuring that they meet specified
requirements, are delivered on time, within budget, and are of high quality.

Characteristics of Software Engineering

1. Systematic Approach: Software engineering follows a systematic and structured approach to

software development.

2. Requirements Engineering: It focuses on understanding, documenting, and managing software

requirements, ensuring that they accurately reflect the needs of stakeholders and align with
business objectives.

3. Design and Architecture: Software engineering involves the design and architecture of software
systems including defining software components.

4. Development and Implementation: It encompasses the coding, testing, and integration of

software components to create functional software products.
5. Testing and Quality Assurance: Software engineering emphasizes rigorous testing and quality
assurance processes to verify that software systems meet specified requirements.

6. Project Management: It involves project planning, estimation, scheduling, and resource allocation
to ensure that software projects are completed on time, within budget, and according to
predefined scope and quality objectives.

7. Continuous Improvement: Software engineering promotes continuous improvement through

feedback, reflection, and learning from past experiences.

Responsibilities of a Software Engineer

i. Software Engineer is responsible for designing, developing, testing, and maintaining software
applications, adhering to software engineering principles and best practices.
ii. He/She is a professional who applies principles and practices of software engineering to design,
develop, test, deploy, and maintain software applications and systems.
iii. He/She possess a deep understanding of computer science fundamentals, programming
languages, software development methodologies, and tools to create efficient and reliable
software solutions.
iv. Based on the requirements, software engineers design software architectures. They create a
blueprint that outlines the structure, components, and interactions of the software system
Key Responsibilities of a Software Engineer
• Requirements Analysis: Collaborating with stakeholders to understand their needs and
requirements for software systems.

• Design and Architecture: Creating the overall structure and architecture of software systems,
including defining components, interfaces, and relationships.

• Programming and Development: Writing code to implement software solution.

• Testing and Quality Assurance: Conducting various types of testing, to ensure the quality,
reliability, and performance of software products.

• Deployment and Maintenance: Deploying software applications to production environments and

monitoring performance.

• Collaboration and Communication: Working collaboratively with cross-functional teams, to

deliver software projects effectively.

• Continuous Learning and Improvement: Keeping abreast of advancements in improving skills to

enhance productivity and effectiveness as a software engineer.

Role of a Software Engineer in Designing Software Architecture

• Understanding Requirements: Collaborate with stakeholders to gather and analyze functional and
nonfunctional requirements.
• Choosing Architectural Patterns: Select appropriate architectural styles based on project needs.
Evaluate trade-offs between different patterns.
• Designing Components and Interfaces: Break down the system into modular components.
• Ensuring Scalability and Performance: Design the system to handle growth in users, data, or
transactions.
• Addressing Security and Reliability: Incorporate security best practices

Skills and Qualifications Required by a Software Engineer

• Proficiency in programming languages such as Java, Python, C++, or JavaScript
• Knowledge of software development methodologies like Agile, Scrum, or Kanban
• Understanding of data structures, algorithms, and computer science fundamentals
• Strong problem-solving, analytical, and critical-thinking skills.
• Excellent communication and collaboration skills to work effectively in teams and interact with
stakeholders

Software Engineer can work as one of the followings

• Project Manager: Oversees the planning, execution, and delivery of software projects, managing
resources, schedules, budgets, and risks to achieve project objectives.
• Quality Assurance Engineer: Ensures the quality and reliability of software products through
comprehensive testing, quality assurance processes, and adherence to quality standards
• Requirements Analyst: Analyzes, documents, and manages software requirements, ensuring
that they are complete, clear, and aligned with stakeholder needs and expectations
 • Software Architect: Designs the overall structure and architecture of software systems, defining
key components, interfaces, and relationships to meet functional and non-functional
requirements

What is SDLC?
SDLC is a process followed for a software project, within a software organization. It consists of a detailed
plan describing how to develop, maintain, replace and alter or enhance specific software to meets or
exceeds customer expectations.

SDLC Models
1. Waterfall Model: The Waterfall model is a linear project management methodology that's often
used in software development. It's also known as the Waterfall
2. Iterative Model: The iterative model is a software development approach that breaks down
projects into smaller, manageable chunks called iterations.
3. Spiral model: The Spiral model combines iterative development with risk management. It consists
of four phases: Planning, Risk Analysis, Engineering, and Evaluation.
4. V-Model: is an approach that represents the process in a "V" shape. The left side focuses on
verification activities, while the right side focuses on validation activities.
5. Big Bang Model: The Big Bang Model is an approach that involves minimal planning and focuses
primarily on coding and implementation.
6. Agile Model: is an iterative and incremental software development approach where projects are
divided into small, manageable chunks and delivered in regular cycles

Role of Software Engineering in Modern Technology

The role of software engineering in modern technology is multifaceted and pivotal, influencing nearly
every aspect of our lives.

i. Development of Software Applications: Software engineering is at the core of developing diverse

applications, ranging from mobile apps and web platforms. Software engineers design, develop,
test, and maintain these applications, enabling individuals and organizations to perform various
tasks efficiently and effectively.
ii. Advancements in Artificial Intelligence and Machine Learning: Engineers develop algorithms,
models, and systems that enable machines to learn from data, make predictions, and perform
tasks autonomously. AI and ML technologies power virtual assistants, recommendation systems,
autonomous vehicles, and other intelligent systems.
iii. Internet of Things (IoT) Development: Software engineering plays a crucial role in the
development of IoT solutions, which connect physical devices and sensors to the internet,
enabling data collection, monitoring, and control.
iv. Cloud Computing and Infrastructure: Software engineering underpins the development and
management of cloud computing infrastructure and services. Engineers build scalable, reliable,
and secure cloud platforms, enabling organizations to access computing resources.
v. Cybersecurity and Data Protection: by developing secure software systems and implementing
robust security measures. Engineers design and implement encryption, authentication and other
security mechanisms to protect data.
 vi. Automation and Robotics: enabling the development of autonomous systems and intelligent
robots. Engineers design industrial tools, enhancing productivity, efficiency, and safety across
various industries.
vii. Healthcare and Biotechnology: contributes to advancements in healthcare and biotechnology by
developing software solutions for medical devices, diagnostic tools, electronic health records, and
telemedicine platforms.
viii. Education and Training: Software engineering plays a vital role in education and training by
developing e-learning platforms, educational software, and virtual reality (VR) applications.
Engineers create interactive learning experiences, simulations, and training modules.
Requirements Engineering
A structured process of gathering, documenting, validating, and maintaining software requirements that
Ensures software meets stakeholder needs, functions effectively, and minimizes project risks.
Role of Requirements Engineering

1. Understanding Stakeholder Needs – Engages users and stakeholders to capture their requirements.
2. Defining System Functionalities– Documents specific functions to ensure all necessary features are
included to meet the desired objectives.
3. Specifying Constraints– Identifies performance, legal, and compatibility limitations for compliance,
ensuring that the system operates within defined boundaries.
Types (categories) of Software Requirements
1. Functional Requirements: Define the system’s specific operations and behaviors under different
conditions.
2. Non-Functional Requirements: Address quality attributes like performance, security, and
scalability, it focus on the system's overall performance and behavior.
3. User Requirements: Focus on user interaction, experience, and expectations.
4. System Requirements: Describe interactions between the software and external components. It
defines the environment in which the software will operate and any dependencies that need to
be considered.
5. Business Requirements: Align software with organizational goals and strategies.
Requirements Elicitation Techniques
Requirements elicitation is a crucial phase in the software development lifecycle where stakeholders'
needs and expectations are identified and documented. It involves gathering, analyzing, and prioritizing
requirements to ensure that the final product meets stakeholders' objectives.
1. Interviews: Direct discussions with analysts and stakeholders for in-depth insights.
2. Surveys & Questionnaires: Collect structured feedback from a stakeholder regarding specific
requirements or features.
3. Workshops & Focus Groups: Collaborative brainstorming for requirement alignment by the
stakeholder and project team manager.
a. They enable rapid exploration of ideas, alignment of expectations, and consensus-
building.
b. Dominant personalities or groupthink may influence the outcome,
4. Prototyping: Creates visual representations to validate functionality early to stakeholders.
Requirements Specification & Documentation
1. Requirements Specification: involves capturing, analyzing, and documenting stakeholders' needs,
expectations, and constraints concerning the software system.
2. Documentation: serves as a formal record of the requirements, design, implementation, and
operation of the software system.
a. Requirements Document: Defines functional and non-functional aspects.
b. Design Document: Outlines system architecture and components.
c. Test Plan – Specifies testing strategies and cases.
d. User & Maintenance Manuals – Provide usage and system upkeep guidelines.

Software Design

Defines where the architecture, components, interfaces, and modules of a software system are defined.
It bridges the gap between requirements analysis and implementation, providing a blueprint for
developers to follow.

Software Design key Concepts

1. Abstraction: process of simplifying complexity by focusing on essential details.
2. Modularity: Divides a system into smaller independent and reusable components.
3. Encapsulation: Bundles data and behavior into a single unit while restricting access to internal
details.
4. Coupling: refers to the degree of interdependence between modules in a system. Measures
interdependency between modules (low coupling is ideal).
5. Cohesion: refers to the degree to which the elements within a module are related to each other.
Measures interdependency between modules (low coupling is ideal).

Architectural Patterns
Architectural patterns provide structured approaches to designing software systems. They help in
organizing components and defining interactions based on factors like scalability, maintainability, and
performance.
Common Architectural Patterns:

• Model-View-Controller (MVC): Separates application logic into Model (data and business logic),
View (user interface), and Controller (handles user input and updates the model and view).
• Layered Architecture: Divides the system into layers where each layer has a specific responsibility
and interacts with adjacent layers.
• Microservices: Decomposes systems into independently deployable services.
• Event-Driven Architecture (EDA): Uses events for asynchronous communication and scalability
within a system.
• Service-Oriented Architecture: Organizes the system into reusable, loosely coupled services.
• Hexagonal Architecture: Separates core logic from external dependencies via ports and adapters.
• Component-Based Architecture: Breaks down the system into reusable components with defined
interfaces.
Software Design Principles
These principles ensure maintainability, scalability, and efficiency in software design:

1. Single Responsibility Principle (SRP): Each module/class should have one responsibility, these to
improve clarity and maintainability.
2. Open/Closed Principle: Software entities should be extendable without modifying existing code.
3. Liskov Substitution Principle (LSP): Subtypes must be usable as their base types without affecting
functionality.
4. Interface Segregation Principle (ISP): Clients should not depend on unnecessary interfaces. it's
better to define smaller, more specific interfaces tailored to the needs of individual clients
5. Dependency Inversion Principle: High-level modules should depend on abstractions, not concrete
implementations.
Software Design Techniques

Top-Down Design: A structured method that begins with a high-level system view and progressively
breaks it down into smaller, manageable components and more detailed modules.

Steps:

• Problem Understanding: Define requirements and objectives.

• High-Level Design: Identify key components and their interactions.
• Decomposition: Break the system into smaller modules.
• Refinement: Further define and detail modules.
• Implementation: Develop and integrate components from top to bottom.
• Integration & Testing: Ensure all parts work together.
• Validation & Verification: Confirm that the system meets requirements.
Advantages:

i. Simplifies complex systems.

ii. Enhances clarity
iii. Enhances modularity.
iv. Promotes reusability
v. Promotes flexibility.

Bottom-Up Design

Bottom-Up Design is a software design approach that starts with the implementation of individual
components or modules and gradually integrates them to form higher-level functionalities or systems.

Steps

i. Component Implementation: The design process begins by implementing individual components

or modules that perform specific tasks or provide specific functionalities.
ii. Unit Testing: Each component is tested in isolation to ensure that it functions correctly and meets
its specified requirements.
 iii. Component Integration: Once the individual components have been implemented and tested,
they are integrated together to form larger structures or systems.
iv. Integration Testing: integration testing is performed to verify that the entire system functions
correctly as a whole. This involves testing the interactions between components and ensuring that
they communicate and collaborate effectively.
v. System Testing: the entire system is tested as a whole to validate that it meets the specified
requirements and performs as expected under various conditions.

Advantages of Bottom-Up Design

• Incremental Development: Bottom-Up Design allows for incremental development, where

individual components are developed and tested independently before being integrated into the
larger system.
• Early Feedback: This helps identify and address issues early on, reducing the risk of problems later
in the development process.
• Modularity and Reusability: by focusing on building smaller, reusable components that can be
easily integrated into different systems or applications.
• Parallel Development: allows for parallel development by multiple teams or developers. it helps
accelerate the development process and improve overall productivity

Object-Oriented Design (OOD)

Object-Oriented Design (OOD) is a methodology based on the principles of encapsulation, inheritance,

and polymorphism. It focuses on modelling systems as interacting objects with defined attributes and
behaviours. OOD follows Object-Oriented Analysis (OOA) and uses its outputs—like use cases and system
models—to design classes, objects, relationships, and interfaces. It lays the groundwork for implementing
software using object-oriented programming languages (OOPLs).

Key concepts
1. Objects: Objects are the fundamental building blocks of an object-oriented system. An object
represents a real-world entity
2. Classes: A class is a blueprint or template for creating objects of a particular type. It defines the
structure and behavior of objects belonging to that class.
3. Inheritance: Inheritance is a mechanism that allows a class (subclass or derived class) to inherit
properties and behavior from another class (superclass or base class).
4. Encapsulation: Encapsulation is the principle of bundling data and methods that operate on that
data into a single unit (class) and hiding the internal implementation details from external entities.
5. Polymorphism: Polymorphism allows objects of different classes to be treated as objects of a
common superclass through method overriding and method overloading.

principles and best practices

• Modularity: refers to the practice of breaking down a system into smaller, self-contained modules
or components.
• Abstraction: is a fundamental concept that involves simplifying complex systems by focusing on
the essential characteristics while hiding unnecessary details.
• Composition: is a principle that allows objects to be composed of other objects as parts, forming
a "has-a" relationship.
 • Association: association refers to a relationship between two or more classes that describes how
they are connected or interact with each other
o Relationship between Classes: Association defines a relationship between classes,
indicating that instances of one class are somehow related to instances of another class.
o Directionality: Associations can be uni-directional or bi-directional, depending on
whether the relationship is symmetric or asymmetric. I
o Multiplicity: Multiplicity specifies how many objects of each class are involved in the
association.
o Role Names: Role names provide names for the roles that each class plays in the
association.
o Navigability: Navigability indicates whether an object in one class can access objects in
the associated class directly.
o Association Classes: In some cases, associations may have attributes or behaviors of their
own.
Associations are typically represented in UML diagrams using lines connecting the participating
classes, with labels indicating the multiplicity, role names, and navigability.

Design Patterns
Design patterns are reusable solutions to common problems encountered in software design. Design
patterns provide proven solutions to design challenges and promote design flexibility and
maintainability

Categories of Design Patterns

1. Creational Patterns: focus on object creation mechanisms, providing flexible ways to create
objects while hiding the instantiation logic.
When to use
• Complex Object Creation Logic
• Encapsulation of Object Creation
• Promoting Code Reusability
• Decoupling Client Code
2. Structural Patterns: deal with object composition and class relationships, emphasizing how
objects are connected to form larger structures.
When to use
• Code Reusability
• Flexibility and Modifiability
• Performance Optimization
• Simplifying Complex Systems
3. Behavioral Patterns: focus on communication and interaction between objects, defining how
objects collaborate to fulfill tasks and responsibilities.
When to use
• Dynamic Behavior Modification
• Promoting Flexibility
• Managing Complex Interactions
• Encapsulating Algorithms
Software Development Methodologies
1. Agile development methodology: Teams use this methodology to minimize risk when adding
new functionality. teams develop the software in iterations that contain Mini increments of the
new functionality.

Pros:
• it allows software to be released in iterations
• allow users to realize software benefits earlier
• Problems are detected and fixed at the early stage
• Eliminated time of project deliverables
• Top-notch quality of the final product
cons:
• rely on real-time communication
• They require a huge time commitment from users
• labor intensive because developers must fully complete each feature within each
iteration for user approval
• Requires immediate responding to issues and feedback in real-time
• Easy to get lost in details and be pulled off the project course
2. DevOps deployment methodology: DevOps is not just a development methodology but also a
set of practices that supports an organizational culture. DevOps deployment centers on
organizational change that enhances collaboration between the departments responsible for
different segments of the development life cycle

Pros:
• DevOps is focused on improving time to market
• minimizing disruption while maximizing reliability.
• shortening the lead time between fixes
 Cons:
• Some customers don’t want continuous updates to their systems
• Some quality attributes require human interaction, which slows down the delivery
pipeline
• Some industries have regulations that require extensive testing
3. Waterfall development methodology: The waterfall method is a rigid linear model that consists
of sequential phases focusing on distinct goals. Each phase must be 100% complete before the
next phase can start.

Major benefit
• All the processes are easy to understand
• Enforced discipline and better keeping the timelines
• All the steps of testing scenarios are planned in advance
• No financial risks due to the high planning accuracy
• The project plan is simple and straightforward
Draw backs
• The planning stage can be too challenging to organize the entire process
• A longer time of delivery
• Weak for long or ongoing projects
• Low flexibility and inability to implement the changes once the software development
process is started

Software Testing
Software testing is an art of investigating software to ensure that its quality under test is in line with the
requirement of the client which is carried out in a systematic manner with the intent of finding defects
in a system.
major benefits of Software Testing

i. Software testing is required to check the reliability of the software

ii. ensures that the system is free from any bug that can cause any kind of failure
iii. ensures that the product is in line with the requirement of the client
iv. It is required to make sure that the final product is user friendly

Test case design techniques

It's essential to select the right combination of techniques based on project requirements, resources,
and constraints to achieve optimal test coverage and maximize the effectiveness of testing efforts.

Objectives of Test Case Design

• To ensure comprehensive test coverage.

• To uncover defects in the software.
• To validate that the software meets the specified requirements.
• To verify the software's behavior under various conditions.
• To minimize the number of test cases while maximizing coverage.

Common Test Case Design Techniques

1. Equivalence Partitioning
• Divide the input domain into classes or partitions.
• Choose one representative value from each partition as a test case.
• Reduces the number of test cases while ensuring coverage of different input scenarios.
2. Boundary Value Analysis (BVA)
• Focuses on testing the boundaries between equivalence partitions.
• Helps uncover errors that may occur at boundary conditions.
3. Decision Table Testing
• Models’ complex business rules or logical conditions using decision tables
• Ensures comprehensive coverage of different scenarios.
4. State Transition Testing
• Suitable for systems with different states or modes
• Helps ensure that the system behaves as expected in different states
5. Use Case Testing
• Derive test cases from use cases that describe interactions between users and the
system.
• Ensures that the software meets user requirements and expectations
6. Pairwise Testing (Combinatorial Testing)
• Tests all possible pairs of input parameters while minimizing the number of tests
• Helps achieve adequate coverage with fewer test cases.
7. Error Guessing
• Helps achieve adequate coverage with fewer test cases.
• Test cases are designed to expose these anticipated errors.
What is a Test Suite?
Test suite is a container that has a set of tests which helps testers in executing and reporting the test
execution status.

Test suite is a container that has a set of tests which helps testers in executing and reporting the test
execution status.

Test suites are created based on the cycle or based on the scope. It can contain any type of tests

Automated Testing

Automated testing is a software testing technique that involves the use of specialized tools and scripts
to execute test cases and compare actual outcomes with expected results automatically.
Objectives of Automated Testing

• Increase testing efficiency by executing test cases quickly and repeatedly.

• Enhance test coverage by running a large number of test cases in a short amount of time.
• Improve accuracy by eliminating human errors associated with manual testing.
• Facilitate regression testing to ensure that recent changes or enhancements do not introduce
new defects.
• Support continuous integration and delivery pipelines by automating the testing phase.

Common Types of Automated Testing

1. Unit Testing: Focuses on testing individual units or components of the software in isolation
Helps validate the correctness of individual units of code.
2. Integration Testing: Verifies the interactions and communication between different modules or
components of the software, ensuring that integrated components work together as expected.
3. Functional Testing: Validates the functional requirements of the software by executing test
cases against its user interface or APIs to Verifies that the software behaves according to
specified functional requirements.
 4. Regression Testing: Re-runs previously executed test cases to ensure that recent changes or
enhancements have not introduced new defects or regressions.
5. Performance Testing: Evaluates the performance characteristics of the software under various
load conditions.

Benefits of Automated Testing

• Saves time and effort by executing test cases quickly and repeatedly
• Enhances accuracy by eliminating human errors associated with manual testing.
• Facilitates early detection of defects, leading to better software quality.
• Improves test coverage by running a large number of test cases in a short amount of time.

Challenges of Automated Testing

• Initial setup and configuration of automated testing frameworks may require time & effort
• Maintenance of automated test scripts can become challenging as the software evolves
• Automated tests may yield false positives or false negatives if not designed and maintained
properly.
• Automated tests may yield false positives or false negatives if not designed and maintained
properly.
Regression Testing

It’s a critical aspect of software testing that ensures that recent changes or enhancements to a software
application do not adversely affect existing functionality.

Objectives of Regression Testing

• Detecting Regression Defects

• Maintaining Software Quality
Types of Regression Testing

1. Complete Regression Testing: Involves re-executing the entire suite of existing test cases.
2. Selective Regression Testing: Selects a subset of test cases based on the areas of the software
that are affected by recent changes.
3. Unit Regression Testing: Focuses on testing individual units or components of the software after
code modifications.
4. Partial Regression Testing: Combines aspects of complete and selective regression testing.

Regression Testing Techniques

1. Regression Testing Techniques
2. Regression Test Selection
3. Prioritization Techniques

Tools for Regression Testing

• Automated testing frameworks

• Version control systems
• Continuous integration tools
Software Quality Assurance
is a methodology to ensure that the quality of the software product complies with a predetermined set
of standards. SQA refers to a systematic approach to ensuring that software products and processes
adhere to predefined quality standards and meet customer expectations.
components of Software Quality Assurance

1. Quality Planning: Establishing quality objectives, processes, and standards for the project.
2. Quality Control: Monitoring and evaluating software development processes to ensure
compliance with quality standards and requirements.
3. Quality Assurance: Implementing systematic processes and procedures to ensure that quality
standards are followed throughout the software development lifecycle
4. Quality Improvement: Continuously improving software development processes and practices
to enhance quality and efficiency.
5. Process Improvement: Identifying inefficiencies, bottlenecks, and areas for improvement in
software development processes.
6. Training and Education: Providing training and education to software development teams on
quality standards, processes, and best practices
7. Documentation and Reporting: Documenting quality assurance processes, procedures, and
activities to ensure consistency and traceability.
Quality Assurance Processes
Quality assurance processes are systematic activities and methodologies implemented to ensure that
software products meet specified quality standards, adhere to requirements, and satisfy customer
expectations. These processes are essential for minimizing defects, optimizing efficiency, and enhancing
overall software quality.

Elements Of Software Quality Assurance

1. Code Reviews: To identify defects, bugs, and vulnerabilities in the code.
Typically involves the author of the code (developer) and one or more reviewers.
Process:
• Preparatory Phase
• Review Phase
• Discussion Phase
• Completion Phase
Benefits:
• Early defect detection and prevention.
• Knowledge sharing and learning opportunities for team members
• Improvement in code quality, readability, and maintainability
• Reduction in rework, technical debt, and bug-fixing costs
2. Code Inspections: To systematically examine code artifacts for defects, inconsistencies, and
deviations from standards.
Typically involves a formal inspection team comprising developers, testers, quality assurance
engineers, and project stakeholders.
Process:
 • Planning Phase
• Preparation Phase
• Inspection Meeting
• Follow-up Phase
Benefits:
• Rigorous examination of code artifacts for defects and quality issues.
• Collaboration and knowledge sharing among cross-functional team members.
• Reduction in defect density, rework, and software maintenance costs.

Configuration Management

Configuration Management (CM) is a systems engineering process for establishing and maintaining
consistency of a product's performance, functional, and physical attributes with its requirements,
design, and operational information throughout its life

Configuration Management Process

1. Planning and Management: This guides the design of the product, who has what
responsibilities, and includes which tools and procedures to use.
2. Identification: Allows for setting baselines and identifying the configuration of assets and/or
software.
3. Control: Maintain control of configurations, change requests, and execution of changes to a
system and its documentation.
4. Status Accounting: The process of recording and reporting configuration item descriptions and
changes from the baseline over the item’s life-cycle.
5. Verification/Audit: Be able to audit what you have implemented and maintain positive control
of all managed product.
Importances of configuration management

1. ensures that the current design and build state of the system is known
2. help in accessing accurate historical record of system
3. knowing what has changed between one set of tests and the next, it helps to identify what could
possibly be causing a fault
4. it reduces risks and errors by helping to identify and mitigate risks associated with changes to
software configurations
5. improves efficiency and productivity through streamlining development processes

Software Measurement and Metrics

Software Measurement is a manifestation of the size, quantity, amount, or dimension of a particular

attribute of a product or process.
metrics and indicators
1. Product Metrics: These metrics focus on quantifying attributes of the software product itself.
2. Process Metrics: These metrics evaluate various aspects of the software development process.
3. Resource Metrics: These metrics measure the resources invested in software development
activities.

Purposes

• Monitoring Progress
• Identifying Quality Issues
• Estimating Effort and Resources
• Supporting Decision-Making

Need for Software Measurement

• Create the quality of the current product or process.

• Anticipate future qualities of the product or process.
• Enhance the quality of a product or process.
• Regulate the state of the project concerning budget and schedule.
• Enable data-driven decision-making in project planning and control.
Classification of Software Metrics

1. Product Metrics: These are the measures of various characteristics of the software product.
a. Size and complexity of software.
b. Quality and reliability of software.
2. Process Metrics: These are the measures of various characteristics of the software development
process.