BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY

NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

Unit I: The Software Product and Software Process

Software Product and Process Characteristics

A process is a set of steps to guide the project in order to obtain the appropriate
product, whereas the product is the final result of the software project

These define the attributes of the software itself, focusing on its functionality,
usability, reliability, and maintainability. Key characteristics include:

1. Functionality
o Ability to perform the required tasks.
o Includes correctness, completeness, and interoperability.
2. Reliability
o Consistency in performance and ability to handle errors gracefully.
o Includes fault tolerance, availability, and recoverability.
3. Usability
o Ease of use and user-friendliness.
o Includes learnability, operability, and accessibility.
4. Efficiency
o Optimal use of system resources, such as memory, CPU, and network.
o Includes time behavior (response time) and resource utilization.
5. Maintainability
o Ease of modifying, extending, and debugging the software.
o Includes modularity, analyzability, and changeability.
6. Portability
o Ability to adapt the software to different environments or platforms.

o Includes installability, replaceability, and compatibility.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

Software Process Characteristics

These define the attributes of the development processes that ensure high-quality
software delivery within constraints like time and budget. Key characteristics
include:

1. Predictability
o Consistent outcomes from the process.
o Measured through adherence to schedules, budgets, and deliverables.
2. Repeatability
o Ability to achieve consistent results across different projects and
teams.
3. Efficiency
o Minimizing time, effort, and resources required to develop the
software.
4. Flexibility
o Ability to accommodate changes in requirements or constraints during
the development lifecycle.
5. Scalability
o Applicability of the process to projects of varying sizes and
complexities.
6. Quality Assurance
o Incorporation of testing, reviews, and validation steps to ensure the
quality of the software.
7. Traceability
o Ability to trace requirements, design decisions, and changes
throughout the lifecycle.
8. Transparency
o Clear visibility into the development process for stakeholders.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

2. Software Process Models

Linear Sequential Model

Phases of the Linear Sequential Model

1. Requirement Analysis
o In this phase, the software's requirements are gathered and documented in detail.
o Deliverables: Requirement Specification Document (e.g., Software Requirements
Specification, or SRS).
2. System Design
o The system's architecture and design are developed based on the requirements.
o Deliverables: High-level design (HLD) and low-level design (LLD) documents,
which detail components, modules, and interfaces.
3. Implementation (Coding)
o Actual development and coding of the software begin based on the design
documents.
o Deliverables: Source code and corresponding documentation.
4. Integration and Testing
o Different modules of the software are integrated and tested for functionality,
performance, and reliability.
o Deliverables: Test plans, test cases, and test reports.
5. Deployment

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

o The completed software is delivered and deployed in the target environment.

o Deliverables: Installed software and user documentation.
6. Maintenance
o Post-deployment, any issues, bugs, or user feedback are addressed, and the system
is updated as needed.
o Deliverables: Patches, updates, or new releases.

Advantages of the Linear Sequential Model

 Simple and Easy to Understand: Its structured, step-by-step process is straightforward.

 Clear Documentation: Each phase is well-documented, aiding communication and
traceability.
 Well-Suited for Stable Requirements: Ideal for projects where requirements are well-
understood and unlikely to change.

Disadvantages of the Linear Sequential Model

 Inflexible to Changes: Once a phase is completed, revisiting it is difficult and costly.

 Late Testing: Testing is done after the implementation phase, making it harder to
identify and fix fundamental design issues early.
 Assumes Stable Requirements: Not suitable for projects where requirements evolve
over time.
 Limited User Feedback: Users are involved primarily during the requirements phase
and may not see the product until it's nearly complete

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

Prototyping Model

The Prototyping Model is a software development model that emphasizes building a prototype
(a working model of the software) early in the development process. It is particularly useful
when requirements are not well-defined or are expected to evolve over time. By creating a
prototype, stakeholders can visualize the product and refine the requirements iteratively.

Phases of the Prototyping Model

1. Requirement Gathering and Analysis

o Initial, high-level requirements are gathered to understand the core functionality
needed.
o These requirements may be vague or incomplete.
2. Quick Design
o A basic design is created to outline the structure and functionality of the
prototype.
o This design focuses on representing key features rather than the full system.
3. Prototype Development
o A working prototype is built based on the quick design.
o This prototype is not a complete product but a functional version that
demonstrates specific features or concepts.
4. Evaluation and Feedback
o Stakeholders (e.g., users and clients) review the prototype and provide feedback.
o This feedback is used to refine and improve the requirements and design.
5. Refinement
o The prototype is updated iteratively based on stakeholder feedback until it aligns
with user expectations.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

o Additional features or changes are incorporated as needed.

6. Final Product Development
o Once the prototype has been refined and approved, it is used as a reference to
develop the complete system.
o The final product is rigorously tested and deployed.

Types of Prototyping

1. Throwaway/Rapid Prototyping
o A temporary prototype is built to gather feedback and clarify requirements.
o It is discarded after use, and the actual system is developed from scratch.
2. Evolutionary Prototyping
o The prototype is continuously refined and evolves into the final product.
o Suitable for systems where requirements are expected to change over time.
3. Incremental Prototyping
o The system is developed in increments, with each increment being a prototype of
a specific module or feature.
o These increments are eventually integrated into the final system.
4. Extreme Prototyping
o Commonly used in web development, it involves three phases: creating a basic
prototype (static pages), programming functionality, and integrating both.

Advantages of the Prototyping Model

 Better Requirement Clarity: Stakeholders can visualize the product early, reducing
ambiguity in requirements.
 User Involvement: Regular feedback ensures the final product aligns with user
expectations.
 Risk Reduction: Identifying and addressing issues early minimizes costly changes later.
 Improved Communication: A tangible prototype facilitates better collaboration between
developers and stakeholders.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

Disadvantages of the Prototyping Model

 Time and Cost Overruns: Frequent changes and iterations may increase development
time and cost.
 Lack of Focus on Documentation: Emphasis on the prototype may lead to inadequate
documentation.
 Scope Creep: Stakeholders may continuously request additional features, delaying
completion.
 Unsuitable for Complex Systems: For large and complex systems, the iterative process
may become unmanageable.

When to Use the Prototyping Model

 When requirements are unclear or expected to change.

 For systems with high user interaction, such as user interfaces.
 In projects where early feedback is critical to success.
 When developing innovative or novel software solutions.

RAD ModeL
The RAD (Rapid Application Development) Model is a software development methodology
that emphasizes speed, flexibility, and user feedback. It focuses on delivering functional
components of the software quickly and iteratively, with active user involvement. This model is
particularly suited for projects where requirements evolve and where rapid delivery of a working
product is critical.

Phases of the RAD Model

1. Business Modeling
o Understand and define the business processes, objectives, and flow of
information.
o The goal is to identify what data is required, how it is processed, and how it will
benefit the business.
2. Data Modeling
o Define the data objects needed for the software and their relationships.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

o Develop a detailed data model that supports the business processes.

3. Process Modeling
o Map out how the data is transformed to meet business goals.
o Define workflows, logic, and rules for data processing.
4. Application Generation
o Develop and assemble functional components using automated tools, frameworks,
or prebuilt modules.
o Focus on rapid construction rather than coding from scratch.
5. Testing and Turnover
o Test the software for functionality, performance, and reliability.
o Since components are built incrementally, continuous testing is integrated
throughout development.

Characteristics of the RAD Model

 Iterative Development: Components are built incrementally and iteratively.

 User Involvement: Frequent user feedback is sought to ensure the product meets
expectations.
 Use of Prototyping: Prototypes are created early to demonstrate functionality.
 Component Reusability: Emphasis on reusing pre-built modules or components to
accelerate development.
 Automated Tools: Heavy reliance on tools for design, coding, and testing (e.g., CASE
tools, GUI builders).

Advantages of the RAD Model

1. Faster Delivery: Speeds up development and delivery compared to traditional models

like the Waterfall.
2. Flexibility: Can adapt to changing requirements more easily.
3. High User Satisfaction: Continuous involvement ensures the product aligns with user
needs.
4. Risk Reduction: Incremental delivery allows issues to be identified and addressed early.
5. Reusability: Leveraging prebuilt components reduces development effort and cost.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

Evolutionary Process Models likeIncremental Model

Evolutionary Process Models are software development approaches that focus on developing
the software incrementally, allowing partial implementation to evolve over time based on user
feedback. These models are particularly useful when requirements are not fully understood at the
start or are expected to change frequently.

The Incremental Model is one of the most widely used evolutionary models.

Incremental Model Overview

The Incremental Model develops a software system in small, manageable increments, each
delivering a part of the functionality. Each increment adds new features or modules until the full
system is complete. Importantly, each increment is fully functional and usable.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

Phases of the Incremental Model

1. Requirement Analysis
o All requirements are gathered upfront but prioritized based on importance and
delivery schedules.
o High-priority requirements are implemented in the early increments.
2. System Design
o A high-level design is created for the entire system, focusing on its architecture
and module interconnections.
3. Implementation of Increments
o The system is developed in increments. Each increment involves:
 Detailed design.
 Coding and unit testing.
 Integration testing of the new increment with existing increments.
4. Testing of the Increment
o Each increment undergoes thorough testing to ensure it works as intended and
integrates with previously delivered components.
5. Delivery and Deployment
o After testing, the increment is deployed, and feedback is collected from users.
o This feedback may influence subsequent increments.
6. Integration and Final Testing
o After all increments are developed, the complete system is subjected to final
integration and testing to ensure overall functionality.

Advantages of the Incremental Model

1. Early Delivery
o Users get access to a working product early in the development process.
2. Flexibility
o Accommodates changes in requirements during development.
3. Risk Reduction
o Issues are identified and resolved early, as smaller parts are built and tested
iteratively.
4. User Feedback
o Early user feedback ensures the software aligns with user expectations.
5. Prioritization
o Critical functionalities are delivered first, which is beneficial in time-sensitive
projects.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

6. Cost-Effectiveness
o Smaller, iterative cycles allow for better budget management.

Disadvantages of the Incremental Model

1. Requires Careful Planning

o Proper prioritization and division of functionalities are essential to avoid delays.
2. Integration Challenges
o Integrating new increments with previous ones may lead to complexity if not
managed properly.
3. Dependency Issues
o Increments may depend on functionality from later increments, complicating
development.
4. Resource Intensive
o Requires constant involvement of users and stakeholders, along with rigorous
testing after each increment.
5. Not Suitable for All Projects
o Less effective for small-scale projects or projects with very stable requirements.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

Spiral Model

The Spiral Model is an evolutionary software development model that combines elements of
iterative development with systematic risk management. It is ideal for large, complex, and high-
risk projects, where requirements are likely to evolve over time. The model emphasizes repeated
cycles of planning, development, and evaluation, with a focus on identifying and mitigating risks
at each iteration.

Phases of the Spiral Model

The Spiral Model consists of multiple cycles, each divided into four key phases. Each cycle
represents a step closer to the final product.

1. Objective Setting and Planning (Determine Objectives)

o Identify objectives, constraints, and risks for the specific phase of the project.
o Define alternatives for achieving objectives, including potential designs and
approaches.
2. Risk Assessment and Reduction (Identify and Resolve Risks)
o Evaluate identified risks for their impact on the project.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

oDevelop strategies to mitigate risks, such as creating prototypes or performing

simulations.
o If risks are too high, the project may be re-planned or even terminated.
3. Development and Validation (Engineering Phase)
o Develop a prototype or part of the system that addresses the objectives of the
current cycle.
o Validate this component through testing or user feedback.
4. Evaluation and Planning for the Next Cycle (Review and Plan)
o Review the progress and deliverables of the current cycle with stakeholders.
o Plan the objectives, scope, and risks for the next cycle.
o Stakeholders decide whether to proceed, modify, or stop the project.

This process continues through multiple spirals (iterations) until the final product is delivered.

Key Features of the Spiral Model

 Risk Management: Risk identification and mitigation are central to every phase.
 Iterative Development: Each spiral builds on the previous one, incorporating feedback
and refining the product.
 Prototyping: Prototypes are often used to clarify requirements, reduce risks, or test
components.
 Customer Involvement: Regular stakeholder reviews ensure alignment with
expectations.
 Flexibility: The model adapts to changing requirements and project needs.

Advantages of the Spiral Model

1. Effective Risk Management

o Risks are continuously evaluated and mitigated, reducing the likelihood of project
failure.
2. Flexibility to Changes
o Accommodates changes in requirements at any stage of the development process.
3. Customer Collaboration
o Regular involvement of stakeholders ensures the product meets expectations.
4. Improved Resource Allocation
o Critical areas of the project are prioritized based on risk and importance.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

5. Early Detection of Issues

o Problems are identified and addressed early, minimizing costly rework later.

Disadvantages of the Spiral Model

1. Complexity
o Managing the iterative cycles and risk assessments can be complex and resource-
intensive.
2. High Cost
o Frequent reviews, prototyping, and risk analysis can make this model expensive.
3. Requires Expertise
o Effective risk assessment and management require experienced teams and tools.
4. Not Suitable for Small Projects
o For small-scale or straightforward projects, the overhead of the Spiral Model may
outweigh its benefits.
5. Difficulty in Setting End Goals
o Iterative cycles and evolving requirements may make it challenging to define a
fixed endpoint.

When to Use the Spiral Model

 For large and complex projects with high risk or significant uncertainty.
 When requirements are likely to evolve or are not well-understood at the outset.
 In systems requiring frequent updates or integrations, such as enterprise software.
 When incorporating new technologies or dealing with projects involving high technical
or operational risks.

Comparison with Other Models

1. Spiral Model vs. Waterfall Model

o The Waterfall Model is linear and rigid, while the Spiral Model is iterative and
flexible.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

o The Spiral Model focuses on risk management, whereas the Waterfall Model
assumes stable requirements.
2. Spiral Model vs. Agile Model
o Both are iterative, but Agile emphasizes collaboration and quick delivery of
increments, while the Spiral Model emphasizes risk management.
o Agile is more lightweight and suited for smaller teams, whereas the Spiral Model
is better for complex, high-risk projects.

Component Assembly Model

 The component-based assembly model uses object-oriented technologies. In object-

oriented technologies, the emphasis is on the creation of classes. Classes are the entities
that encapsulate data and algorithms. In component-based architecture, classes (i.e.,
components required to build application) can be uses as reusable components. This
model uses various characteristics of spiral model. This model is evolutionary by nature.
Hence, software development can be done using iterative approach. In CBD model,
multiple classes can be used.

These classes are basically the prepackaged components. The model works in following manner:

 Step-1: First identify all the required candidate components, i.e., classes with the help of
application data and algorithms.
 Step-2: If these candidate components are used in previous software projects then they
must be present in the library.
 Step-3: Such preexisting components can be excited from the library and used for further
development.
 Step-4: But if the required component is not present in the library then build or create the
component as per requirement.
 Step-5: Place this newly created component in the library. This makes one iteration of the
system.
 Step-6: Repeat steps 1 to 5 for creating n iterations, where n denotes the number of
iterations required to develop the complete application.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

 Characteristics of Component Assembly Model:

 Uses object-oriented technology.
 Components and classes encapsulate both data and algorithms.
 Components are developed to be reusable.
 Paradigm similar to spiral model, but engineering activity involves components.
 The system produced by assembling the correct components.

Rational Unified Process (RUP)

Rational Unified Process (RUP) is a software development process for object-oriented models.
It is also known as the Unified Process Model. It is created by Rational Corporation and is
designed and documented using UML (Unified Modeling Language). This process is included in
the IBM Rational Method Composer (RMC) product. IBM (International Business Machine
Corporation) allows us to customize, design, and personalize the unified process.
RUP is proposed by Ivar Jacobson, Grady Bootch, and James Rambaugh. Some characteristics of
RUP include being use-case driven, Iterative (repetition of the process), incremental (increase in
value) by nature, delivered online using web technology, can be customized or tailored in
modular and electronic form, etc. RUP reduces unexpected development costs and prevents the
wastage of resources.
Phases of RUP
There is a total of five phases of the life cycle of RUP:
1. Inception
2. Elaboration
3. Construction
4. Transition
5. Production

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

1. Inception –
 Communication and planning are the main ones.
 Identifies the scope of the project using a use-case model allowing managers to estimate
costs and time required.
 Customers’ requirements are identified and then it becomes easy to make a plan for the
project.
 The project plan, Project goal, risks, use-case model, and Project description, are made.
 The project is checked against the milestone criteria and if it couldn’t pass these criteria
then the project can be either canceled or redesigned.
2. Elaboration –
 Planning and modeling are the main ones.
 A detailed evaluation and development plan is carried out and diminishes the risks.
 Revise or redefine the use-case model (approx. 80%), business case, and risks.
 Again, checked against milestone criteria and if it couldn’t pass these criteria then again
project can be canceled or redesigned.
 Executable architecture baseline.
3. Construction –
 The project is developed and completed.
 System or source code is created and then testing is done.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

 Coding takes place.

4. Transition –
 The final project is released to the public.
 Transit the project from development into production.
 Update project documentation.
 Beta testing is conducted.
 Defects are removed from the project based on feedback from the public.
5. Production –
 The final phase of the model.
 The project is maintained and updated accordingly.
Advantages of Rational Unified Process (RUP)
Following are the advantages of Rational Unified Process (RUP):
1. RUP provides good documentation, it completes the process in itself.
2. RUP provides risk-management support.
3. RUP reuses the components, and hence total time duration is less.
4. Good online support is available in the form of tutorials and training.
Disadvantages of Rational Unified Process (RUP)
Following are the disadvantages of Rational Unified Process (RUP):
1. Team of expert professional is required, as the process is complex.
2. Complex and not properly organized process.
3. More dependency on risk management.
4. Hard to integrate again and again.

Agile Processes

Agile refers to a group of lightweight methodologies designed for flexibility, collaboration, and
iterative development. Common Agile frameworks include Scrum, Kanban, Extreme
Programming (XP), and Lean.

Key Characteristics

1. Iterative and Incremental: Development occurs in small, time-boxed iterations (e.g., 2-

week sprints in Scrum).
2. Flexibility: Responds quickly to changing requirements, even late in development.
3. Collaboration: Focuses on cross-functional teams and customer involvement throughout
the project.
4. Working Software: Prioritizes delivering functional software over comprehensive
documentation.
5. Principles (as per the Agile Manifesto):
o Individuals and interactions over processes and tools.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

oWorking software over comprehensive documentation.

oCustomer collaboration over contract negotiation.
oResponding to change over following a plan.
6. Lightweight Process: Suitable for small to medium-sized projects where adaptability is
crucial.

Comparison: RUP vs Agile

Aspect RUP Agile

Philosophy Process-centric and predictive People-centric and adaptive

Process Prescriptive, well-defined phases Flexible, evolving through iterations

Extensive documentation and Minimal documentation, focus on

Documentation
artifacts software

Team Collaboration Role-driven, hierarchical Collaborative and self-organizing

Change Embraces change throughout

Formal change requests
Management development

Iteration Length Longer iterations within each phase Short, time-boxed sprints or iterations

Large, complex projects with defined Dynamic, fast-changing

Suitability
goals environments

When to Use RUP vs Agile

 Use RUP when:

o You are working on a large, complex, or critical system (e.g., defense, banking,
healthcare).
o Detailed documentation and risk management are required.
o The project has clear requirements from the outset.
 Use Agile when:

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

o The requirements are uncertain or likely to evolve.

o Rapid delivery of a working product is needed.
o Collaboration and quick feedback are essential.

CMM in Software Engineering

CMM (Capability Maturity Model) is a framework used in software engineering to evaluate and
improve the maturity of an organization's software development processes. Developed by the
Software Engineering Institute (SEI) at Carnegie Mellon University, CMM provides a structured
pathway for organizations to progress from immature, ad-hoc processes to mature, well-defined,
and optimized software practices.

Purpose of CMM

The primary goal of CMM is to:

 Improve software quality.

 Reduce development costs.
 Ensure predictable project delivery timelines.
 Provide a systematic roadmap for process improvement.

CMM Maturity Levels

CMM is divided into five maturity levels that represent an organization's process capabilities:

Level 1: Initial (Chaotic/Ad Hoc)

 Characteristics:
o Processes are ad-hoc, unstructured, and reactive.
o Success depends on individual efforts rather than defined processes.
o Projects often exceed budgets and deadlines.
 Challenges:
o Unpredictable outcomes.
o High reliance on key individuals.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

Level 2: Repeatable

 Characteristics:
o Basic project management processes are established.
o Success is repeatable for similar projects.
o Focus is on managing requirements, timelines, and budgets.
 Key Processes:
o Requirements management.
o Project planning.
o Quality assurance.

Level 3: Defined

 Characteristics:
o Processes are documented and standardized across the organization.
o A strong emphasis on process definition and institutionalization.
o Teams follow established guidelines and best practices.
 Key Processes:
o Organizational process focus.
o Risk management.
o Peer reviews.

Level 4: Managed (Quantitatively Controlled)

 Characteristics:
o Processes are measured and controlled using quantitative data.
o Data-driven decision-making to predict performance.
o Variations in processes are identified and addressed.
 Key Processes:
o Quantitative process management.
o Performance analysis.

Level 5: Optimizing

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

 Characteristics:
o Continuous process improvement is the focus.
o Innovations and lessons learned are incorporated into processes.
o Emphasis on defect prevention and process optimization.
 Key Processes:
o Continuous improvement.
o Process innovation.

Key Benefits of CMM

1. Predictable Results: Organizations can deliver projects on time and within budget.
2. Improved Quality: High process maturity leads to fewer defects.
3. Scalability: Processes are standardized, enabling scaling for larger projects.
4. Customer Confidence: Clients trust organizations with higher maturity levels.

Criticism of CMM

1. Rigid Framework: The model may be too rigid for dynamic environments like Agile
software development.
2. Costly Implementation: Achieving higher levels of maturity requires significant time
and financial investment.
3. Documentation Overload: Focus on documentation can sometimes outweigh actual
process improvements.

Product and Process Metrics

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

Metrics are quantitative measures used to evaluate, control, and improve software development
processes and the quality of the software product. They help software engineers make data-
driven decisions, identify issues, and ensure project success.

1. Product Metrics

Product metrics focus on measuring the attributes and quality of the software product itself. They
evaluate the software’s functionality, performance, maintainability, and reliability.

Types of Product Metrics

1. Size Metrics:
o Lines of Code (LOC): Measures the total number of lines in the source code.
o Function Points (FP): Estimates the size of software based on its functional
requirements.
2. Complexity Metrics:
o Cyclomatic Complexity: Measures the number of independent paths in the
program’s control flow. High complexity indicates higher testing and
maintenance efforts.
o Halstead Metrics: Measures complexity based on the number of operators and
operands in the code.
3. Quality Metrics:
o Defect Density: Number of defects per unit of code (e.g., defects per KLOC).
o Reliability: Measures the probability of failure-free operation in a given time
frame.
4. Performance Metrics:
o Response Time: Time taken to respond to a user input.
o Throughput: Amount of work completed in a given time period.
o Resource Utilization: Measures CPU, memory, or disk usage during operation.

2. Process Metrics

Prepared By-Prof.Sana Khan

CSE Dept(BIST)
 BANSAL INSTITUTE OF SCIENCE AND TECHNOLOGY
NOTES UNIT-1

SOFTWARE ENGINEERING CS-403

Process metrics measure and monitor the efficiency and effectiveness of the software
development process. They help identify bottlenecks, track progress, and improve workflows.

Types of Process Metrics

1. Project Management Metrics:

o Effort Estimation: Tracks actual effort (in person-hours or person-days) against
planned effort.
o Schedule Variance (SV): Measures the deviation between planned and actual
schedules.
o Cost Variance (CV): Compares actual costs to planned costs.
2. Productivity Metrics:
o Productivity: Lines of Code (LOC) or Function Points (FP) produced per unit of
effort.
o Velocity: Amount of work (e.g., story points) completed per sprint in Agile
projects.
3. Defect Metrics:
o Defect Removal Efficiency (DRE): Measures the percentage of defects found
and fixed during development.
o Defect Injection Rate: Tracks the rate at which defects are introduced into the
system during development.
4. Process Quality Metrics:
o Process Cycle Time: Time taken to complete a single iteration or phase of the
development process.
o Lead Time: Time from request initiation to delivery.
o Rework Percentage: Amount of time spent fixing defects compared to total
development time.

Prepared By-Prof.Sana Khan

CSE Dept(BIST)