Savitribai Phule Pune University

S.Y.B.Sc. (Computer Science) - SEM – III

Course Title: Software Engineering (CS 221-VSC-T)

Chapter - 1 Introduction to Software Engineering

1.1 Definition of Software

In software engineering, software refers to a collection of computer programs, procedures, and
associated documentation that, when executed, provides desired features, functionality, and
performance. It essentially encompasses all the non-tangible components of a computer system,
including the instructions, data structures, and documentation needed to operate and maintain the
system.

 Instructions (Computer Programs): These are the sets of commands written in a programming
language that tell the computer what to do.
 Data Structures: These are ways of organizing and storing data that the programs use to
perform their tasks.
 Documentation: This includes all the descriptive information, both in hard copy and virtual
forms that explains how the software works and how to use it.

1.2 Nature of Software Engineering

What is Software Engineering? - Software engineering is the application of engineering principles

and systematic methods to the development, operation, and maintenance of software. It aims to
produce reliable, efficient, and cost-effective software solutions that meet user requirements.

Nature of Software Engineering

Software engineering is the disciplined, systematic, and quantifiable approach to the development,
operation, and maintenance of software. It applies engineering principles to software creation with the
goal of building reliable, efficient, and maintainable software systems.

Key characteristics of the nature of software engineering include:

 Engineering Discipline — uses proven methods, models, and best practices to produce high-
quality software.
 Systematic Process — Follows defined processes such as requirement analysis, design, coding,
testing, deployment, and maintenance.
 Manageability — Breaks down complex problems into manageable components through
structured design and modular development.
 Quality Focused — Emphasizes reliability, performance, usability, maintainability, and security.
 Dynamic and Evolving — Adapts to changes in technology, user requirements, and
environments.
 Team-Oriented — Encourages collaboration among developers, testers, project managers, and
stakeholders.
 Cost and Time Conscious — Aims to deliver software within budget and deadlines without
compromising quality.

1.3 Changing nature of software

Software isn’t a “one-and-done” product; it evolves over time to keep up with changing needs,
technology, and environments. Here’s how:

1. Changing User Needs

Users often request new features or improvements after using a product.
Example: WhatsApp started as a simple messaging app but evolved to include voice calls,
video calls, payments, and communities in response to user demands.

2. Technological Advances
New hardware, devices, or platforms force software updates or redesigns.
Example: Microsoft Office has changed drastically to support touchscreens, cloud storage
(OneDrive), and mobile devices.

3. Business and Market Dynamics

Competition or new business models lead to rapid software changes.
Example: Netflix shifted from DVD rentals to online streaming, requiring them to completely
redesign their software platform.

4. Security Threats
As hackers develop new attacks; software must be updated to fix vulnerabilities.
 Example: Operating systems like Windows, macOS, and Android regularly release security
patches in response to discovered threats.

5. Maintenance and Enhancements

Software needs updates to fix bugs, improve performance, or ensure compatibility with new
systems.
Example: Game developers release patches after launch to fix bugs or balance gameplay.

6. Globalization and Connectivity

Software must adapt to serve global users across different languages, regulations, and
cultures.
Example: E-commerce platforms like Amazon continuously update their software to handle
new countries, currencies, and local compliance requirements.

1.4 Mc Call’s Quality factors

What is McCall's Software Quality Model?

McCall's Software Quality Model was introduced in 1977. This model is incorporated with many
attributes, termed software factors, which influence software. The model distinguishes between two
levels of quality attributes:
 Quality Factors
 Quality Criteria

Quality Factors: The higher-level quality attributes that can be accessed directly are called quality
factors. These attributes are external. The attributes at this level are given more importance by the
users and managers.
Quality Criteria: The lower or second-level quality attributes that can be accessed either subjectively
or objectively are called Quality Criteria. These attributes are internal. Each quality factor has many
second-level quality attributes or quality criteria.

Example: The usability quality factor is divided into operability, training, communicativeness,
input/output volume, and input/output rate. This model classifies all software requirements into 11
software quality factors. The 11 factors are organized into three product quality factors:
Factors of Product Quality
1. Product Operation
2. Product Revision
3. Product Transition

1) Product Operation
Product Operation includes five software quality factors, which are related to the requirements that
directly affect the operation of the software such as operational performance, convenience, ease of
usage, and correctness. These factors help in providing a better user experience.
a) Correctness: The extent to which software meets its requirements specification.
b) Efficiency: The number of hardware resources and code the software, needs to perform a
function.
c) Integrity: The extent to which the software can control an unauthorized person from accessing
the data or software.
d) Reliability: The extent to which software performs its intended functions without failure.
e) Usability: The extent of effort required to learn, operate, and understand the functions of the
software.

2) Product Revision
Product Revision includes three software quality factors, which are required for testing and
maintenance of the software. They provide ease of maintenance, flexibility, and testing efforts to
support the software to be functional according to the needs and requirements of the user in the
future.
a) Maintainability: The effort required to detect and correct an error during maintenance.
b) Flexibility: The effort needed to improve an operational software program.
c) Testability: The effort required to verify software to ensure that it meets the specified
requirements.

3) Product Transition
Product Transition includes three software quality factors, that allow the software to adapt to the
change of environments in the new platform or technology from the previous.
a) Portability: The effort required to transfer a program from one platform to another.
 b) Re-usability: The extent to which the program's code can be reused in other applications.
c) Interoperability: The effort required to integrate two systems.

Need of Software Engineering:

 Handling Big Projects: A corporation must use a software engineering methodology in order to
handle large projects without any issues.

 To manage the cost: Software engineering programmers plan everything and reduce all those
things that are not required.
 To decrease time: It will save a lot of time if you are developing software using a software
engineering technique.

 Reliable software: It is the company's responsibility to deliver software products on schedule

and to address any defects that may exist.

 Effectiveness: Effectiveness results from things being created in accordance with the
standards.

 Reduces complexity: Large challenges are broken down into smaller ones and solved one at a
time in software engineering. Individual solutions are found for each of these issues.

 Productivity: Because it contains testing systems at every level, proper care is done to
maintain software productivity.

1.5 Software Process

Software processes in software engineering serve as the foundational framework for designing,
developing, testing, and maintaining software systems efficiently. These structured methodologies
provide a systematic approach, ensuring organized project management, clear communication, and
high-quality output. They orchestrate the complex journey of turning concepts into functional digital
realities, enhancing collaboration, reducing uncertainties, and optimizing resource allocation from
inception through deployment and beyond.
Common models, including Waterfall, Agile, and DevOps methodologies, offer different perspectives
to customize and refine these processes, aligning them with project intricacies. DevOps, for example,
integrates development and operations, promoting continuous integration and delivery. The interplay
of these methodologies forms the core of efficient software craftsmanship, nurturing teamwork and
yielding sophisticated, forward-looking outcomes amid the ever-evolving technological
landscape.

The Software Process Model

The Software Process Model, also known as the Software Development Life Cycle (SDLC), is a
systematic approach that outlines the stages and activities involved in the creation, development, and
maintenance of software applications. It serves as a framework to guide software development teams
in effectively and efficiently producing high-quality software products. Different process models exist,
each with its own set of stages and activities, but they generally follow a similar structure. One of the
most common process models is the Waterfall model, which I'll use to explain the typical stages:

1. Requirements Gathering and Analysis:

In this initial phase, developers work closely with stakeholders (clients, users, or product
owners) to understand the software's purpose, scope, and functionalities. The requirements
are documented, analyzed, and prioritized to create a clear project roadmap.

2. System Design:

Based on the gathered requirements, the system architecture and design are created. This
phase outlines how the software components will interact, what technologies will be used, and
how the user interface will be designed. This stage is critical for planning and ensuring that the
system will meet the intended goals.

3. Implementation:

In this stage, the actual coding and programming of the software take place. Developers write
the code according to the design specifications. This phase includes both creating the core
functionality of the software and handling any technical challenges that arise during
development.

4. Testing:

After the software is coded, it undergoes rigorous testing. Quality assurance teams identify and
rectify defects, errors, and issues that may arise during execution. Testing ensures that the
software behaves as expected and meets the specified requirements.

5. Deployment:

Once the software passes testing and is considered stable, it is deployed to a production
environment for end-users to access and utilize. Deployment involves configuring the software,
setting up servers, and ensuring all necessary components are in place for smooth operation.
 6. Maintenance and Support:

After deployment, the software enters its maintenance phase. This involves monitoring for any
issues that may arise in the live environment, addressing user feedback, and making
necessary updates or improvements. Regular updates and bug fixes are released to ensure
the software remains reliable and up-to-date.

Software Crisis

The term Software Crisis refers to a historical period in the early days of computing when the
development and maintenance of software systems faced significant challenges that led to concerns
about the feasibility and reliability of software as a whole. This crisis emerged as a result of the rapid
growth of computing technology and the increasing complexity of software applications. The concept
of the Software Crisis highlights the difficulties and inefficiencies encountered during software
development, leading to the exploration of new methodologies and practices to address these issues.

Key factors contributing to the Software Crisis:

1. Complexity:
a. As software systems grew in size and scope, their complexity increased exponentially. It
became increasingly difficult to design, implement, and maintain software without
encountering errors or bugs.
2. Lack of Formal Methods:
a. During the early days of computing, there were limited formal methods and tools
available to aid in the design, specification, and verification of software systems. This
lack of rigor often resulted in unpredictable behavior and errors in software applications.
3. Unreliable Software:
a. Many software projects of the time were plagued by frequent bugs, crashes, and
malfunctions. This undermined user confidence in software systems and hindered the
adoption of technology.
4. Inefficient Development:
a. The process of software development was often ad hoc and lacked structured
methodologies. This led to missed deadlines, cost overruns, and unsatisfactory
outcomes.
5. Rapid Technological Change:
a. The fast-paced evolution of hardware and software platforms further complicated
software development. Compatibility issues arose as systems became outdated quickly.
6. Limited Resources:

Hardware resources were often scarce, and software developers had to work with limited
computational power and memory, making it challenging to create efficient and optimized
software.

Efforts to Address the Software Crisis:

1. Structured Programming:
a. Pioneered by Edsger Dijkstra, structured programming introduced the use of control
structures like loops and conditionals to enhance code readability and reliability.
2. Modular Programming:
 a. Breaking software systems into smaller, manageable modules helped reduce
complexity, improve code reuse, and simplify maintenance.
3. Formal Methods:
a. Researchers started exploring formal methods for specifying, designing, and verifying
software systems to ensure correctness and reliability.
4. Software Engineering:
a. The emergence of software engineering as a discipline emphasized systematic
approaches to software development, including requirements analysis, design, testing,
and maintenance.
5. Object-Oriented Programming:
a. This paradigm promoted the use of objects, encapsulation, and inheritance to model
real-world entities and improve code organization.
6. Agile Methodologies:
a. In response to the rigidity of traditional software development practices, agile
methodologies like Scrum and Extreme Programming (XP) were introduced, focusing
on iterative development, collaboration, and adaptability.
7. Advancements in Tools and Languages:
a. The development of better programming languages, integrated development
environments (IDEs), debugging tools, and version control systems contributed to more
efficient software development processes.

Advantages of Software Process in Software Engineering

1. Consistency:
a. Software processes ensure consistent methods and practices throughout the
development lifecycle, leading to higher quality and fewer errors.
2. Predictability:
a. Defined processes help in estimating project timelines, resource requirements, and
potential risks more accurately, aiding project management.
3. Efficiency:
a. Well-established processes optimize resource utilization, reduce rework, and enhance
productivity by eliminating redundant efforts.
4. Quality Improvement:
a. By following a structured process, defects and errors are detected and corrected early,
resulting in improved software quality.
5. Traceability:
a. Processes allow for proper documentation and tracking of changes, making it easier to
identify and manage modifications throughout the lifecycle.
6. Communication:
a. Clear processes promote effective communication among team members, stakeholders,
and clients, reducing misunderstandings.
7. Risk Management:
a. Processes incorporate risk assessment and mitigation strategies, aiding in identifying
and managing potential project risks.
8. Continuous Improvement:
a. Feedback mechanisms within processes enable ongoing refinement and optimization,
leading to enhanced development practices.
Disadvantages of Software Process in Software Engineering

1. Rigidity:
a. Overly rigid processes can hinder creativity and adaptability, making it challenging to
respond effectively to changing requirements.
2. Bureaucracy:
a. Complex processes can introduce bureaucratic overhead, consuming time and
resources without adding significant value.
3. Overhead:
a. Excessive process documentation and adherence can increase administrative
overhead, diverting focus from actual development.

4. Lack of Fit:
a. Some projects may not align well with standard processes, leading to inefficiencies and
decreased project performance.
5. Learning Curve:
a. Introducing new processes can require training and adjustment periods for team
members, potentially affecting short-term productivity.
6. Costly Implementation:
a. Implementing and maintaining elaborate processes might require investing in tools,
training, and personnel, adding to project costs.
7. Inflexibility:
a. Once a process is established, it might be difficult to modify or replace it, even if it's no
longer the best fit for the project.
8. Overemphasis on Process:

Focusing too much on adhering to processes can lead to neglecting the broader goals of
delivering valuable software and satisfying customer needs.

Examples of Software Processes

Software processes, often referred to as Software Development Life Cycle (SDLC) models, provide a
structured approach to design, develop, test, and maintain software applications. These processes
help teams manage and control the various stages of software development. Here are some
commonly used software processes:

1. Waterfall Model:
 A linear approach where phases (requirement gathering, design, implementation, testing,
deployment) follow a strict sequence. Offers clear structure but struggles with changes post-
phase completion, best suited for straightforward projects.

o Phases: Requirement gathering → System design → Implementation → Integration →

Testing → Deployment → Maintenance.
o Advantages: Clear structure, well-defined stages, easy to manage.
o Disadvantages: Difficult to make changes once a phase is complete, not suitable for
complex or evolving projects.

2. Incremental Model:

Software developed in segments following the Waterfall phases, allowing for early deployment
and adaptable changes. Requires stable requirements for optimal outcomes.

o Phases: Same as the Waterfall model but repeated incrementally.

o Advantages: Early partial deployment of the software, better feedback and adjustment
to requirements.
o Disadvantages: Needs clear and stable requirements for the best outcomes.
3. Iterative Model:

Cyclic development with initial implementation followed by iterations for refining and
enhancing. Supports flexibility and progress through well-defined iterations.

o Phases: Initial implementation → Iterative development → Iterative design and

implementation.
o Advantages: Allows refinement through iterations, more flexibility in design and
development.
o Disadvantages: Can be difficult to manage if iterations are not well-defined.

4. Agile Model:

Promotes collaboration, quick iterations (planning, design, development, testing, review,

deploy). Offers flexibility, faster delivery of features, but less emphasis on documentation.
 o Phases: Planning → Design → Development → Testing → Review → Deploy.
o Advantages: High flexibility, faster delivery of small features, better collaboration and
communication.
o Disadvantages: Less emphasis on documentation, needs experienced team members.

5. V-Model (Validation and Verification):

Aligns development stages with corresponding testing phases for robust validation and
verification. Less flexible but ensures software quality.

o Phases: Requirements → System design → Architecture design → Module design →

Coding → Unit testing → Integration testing → System testing → Acceptance testing.
o Advantages: Emphasis on validation and verification, ensures high software quality.
o Disadvantages: Less flexibility, changes are costly.

6. Spiral Model:
 Prioritizes risk assessment and iteration (planning, risk analysis, engineering, evaluation).
Highlights risk management, iterative approach, demanding risk expertise.

o Phases: Planning → Risk analysis → Engineering → Evaluation.

o Advantages: Strong emphasis on risk management, iterative approach.
o Disadvantages: Can be complex, requires expertise in risk management.

1.6 Software Process Framework

Framework is a Standard way to build and deploy applications. Software Process Framework is a
foundation of complete software engineering process. Software process framework includes all set of
umbrella activities. It also includes number of framework activities that are applicable to all software
projects.

A generic process framework encompasses five activities which are given below one by one:

1. Communication: In this activity, heavy communication with customers and other stakeholders,
requirement gathering is done.

2. Planning: In this activity, we discuss the technical related tasks, work schedule, risks, required
resources etc.

3. Modeling: Modeling is about building representations of things in the ‘real world’. In modeling
activity, a product’s model is created in order to better understanding and requirements.

4. Construction: In software engineering, construction is the application of set of procedures that are
needed to assemble the product. In this activity, we generate the code and test the product in order to
make better product.

5. Deployment: In this activity, a complete or non-complete products or software are represented to

the customers to evaluate and give feedback. On the basis of their feedback we modify the products
for supply better product.

1.7 What is Umbrella Activities?

Umbrella activities are a series of steps or procedures followed by a software development team to
maintain the progress, quality, changes, and risks of complete development tasks. These steps of
umbrella activities will evolve through the phases of the generic view of software development.
The activities in the software development process are supplemented by many general activities.
Generally, common activities apply to the entire software project and help the software
development team manage and track progress, quality, changes, and risks.

Umbrella activities consist of different tasks:

 Software Project Tracking and Control
 Formal Technical Reviews
 Software Quality Assurance
 SCM or Software configuration management
 Document Preparation and Production
 Re-usability Management
 Measurement and Metrics
 Risk Management
Umbrella Activities

 Software project tracking and control: This activity allows the software team to check the
progress of software development. Before the actual development starts, make a software
development plan and develop on this basis, but after a certain period of time, it is necessary to
analyze the development progress to find out what measures need to be taken. It must be
accepted at an appropriate time after the completion of development, testing, etc. The test
results may need to reschedule the development time.
 Risk management: Risk management is a series of steps to help software development teams
understand and manage uncertainty. It is a very good idea to identify it, assess the likelihood of
it happening, assess its impact, and develop an "if the problem does happen" contingency plan.
 Software quality assurance: As its name suggest this defines and conducts the activities
required to ensure software quality. The quality of the software, such as user experience,
performance, workload flexibility, etc., must be tested and verified after reaching the specified
milestones, which reduces the tasks at the end of the development process, which must be
performed by a dedicated team so that the development can continue.
 Technical reviews: It assesses software engineering work products in an effort to uncover and
remove errors before they are propagated to the next activity. Software engineering is done in
clusters or modules, after completing each module, it is good practice to review the completed
module to find out and remove errors so their propagation to the next module can be prevented.
 Measurement: This includes all measurements of all aspects of the software project. Define and
compile process, project, and product metrics to help the team deliver software that meets the
needs of stakeholders; it can be used in conjunction with all other frameworks and general
operations.
 Software configuration management: It manages the impact of changes throughout the
software development process. Software Configuration Management (SCM) is a set of activities
designed to manage changes by identifying work products that can be changed, establishing
relationships between them, and defining mechanisms for managing different versions of them.
Work product.
 Reusability management: Define the standards for the reuse of work products (including
software components), and develop mechanisms to implement reusable components. This
includes the approval of any part of a backing-up software project or any type of support
provided for updates or updates in the future. Update the software according to user/current time
requirements.
 Work product preparation and production: It encompasses the activities required to create
work products such as models, documents, logs, forms, and lists.

1.8 Process Adaptation:

Process Adaptation in Software Engineering refers to tailoring a general software development

process model to meet the specific needs of a particular project, organization, or development
environment.

Definition:

Process adaptation is the act of customizing a standard software process model (like Waterfall,
Agile, Spiral, etc.) based on:

 Project type (size, complexity, criticality)

 Team size and skills
 Organizational culture
 Customer requirements
 Technology stack
 Development environment

Why Process Adaptation is Important:

1. No one-size-fits-all: Not every process fits all projects. A large mission-critical system needs
more rigor than a mobile app prototype.
2. Improved efficiency: Adapted processes remove unnecessary steps and focus on what's
essential.
3. Risk reduction: Adaptation considers specific risks and adds practices to mitigate them.
4. Better team alignment: Adapting ensures the process fits the team’s working style and
capabilities.

Key Steps in Process Adaptation:

 1. Select a base model (e.g., Agile, Waterfall, Spiral).
2. Assess project-specific factors: domain, complexity, timeline, resources.
3. Modify or omit process elements: e.g., reduce documentation, add feedback loops.
4. Define roles, responsibilities, and tools.
5. Establish checkpoints and review mechanisms.
6. Monitor and refine during execution.

Example:

If using Agile for a government project that demands documentation:

 Adapt Agile to include more detailed documentation.

 Add formal approval gates at iteration ends.

Common Adaptation Elements:

Element Adaptation Example

Documentation Lightweight in startups, detailed in regulatory projects

Reviews & Testing Informal in small projects, formal in safety-critical systems

Iteration Length Weekly sprints in fast-paced apps, monthly in enterprise systems

Tools Jira for Agile, MS Project for Waterfall planning