Software Crisis

The software crisis refers to the problems faced during software development
due to increasing complexity and demand. It happens when software takes too
long to develop, has many errors, costs too much, or fails to meet user needs.
This problem was first noticed in the 1960s, when companies started making
large and complex software systems, but old development methods were not
efficient enough to handle them.

Main Reasons for Software Crisis

1. Increasing Complexity of Software:
==> Earlier, software was simple, but now, systems are huge and complicated.
==> More features mean more chances for errors and delays.
Example: A simple calculator app is easy to develop, but a banking system is
highly complex with thousands of functions.

2. Poor Project Management

➔ If a project is not well planned, developers might miss deadlines, go over
budget, or produce low-quality software.
➔Lack of proper teamwork, documentation, and guidelines leads to failure.
Example: If a team starts building an e-commerce website without a plan, they
might forget essential features like a payment gateway or product search.

3. Lack of Skilled Developers 8

➔Many software projects fail because there are not enough experienced
developers.
➔If the team doesn't know how to write efficient code or fix bugs, the project
suffers.
Example: A team of beginners trying to build an Al system without proper
knowledge will struggle.
By-ARMAN ALI

4. Changing User Requirements

Users often change their needs and expectations while the software is being
developed.
Frequent changes delay the project and make previous work useless.
Example: A company wants a mobile banking app, but after a few months, they
ask for extra security features and a chatbot, requiring major changes.

Results of Software Crisis

How Software Engineering Solves the Crisis?

Software Engineering was introduced to solve the software crisis by providing:
Proper Development Methods -- Using SDLC, Agile, and DevOps for efficient
planning.
Better Project Management -- Managing deadlines, costs, and teamwork
properly.
Testing & Quality Assurance -- Ensuring software is bug-free and reliable.
Reusable Code - Avoiding rewriting from scratch by reusing components.
Conventional Engineering Process vs. Software
Engineering Process

What is the Conventional Engineering Process?

Conventional engineering refers to the traditional method of building physical products like
bridges, buildings, machines, and vehicles. It involves designing, constructing, and testing
tangible structures using materials like steel, concrete, and wood.
Example: When constructing a house, engineers follow steps like planning, material
selection, building, and testing for safety.

What is the Software Engineering Process?

Software engineering is the systematic approach to developing software applications, such
as websites, mobile apps, and operating systems. It involves writing code, designing, testing,
and maintaining software to ensure it works properly.
Example: When developing a social media app, software engineers follow steps like
planning, designing, coding, testing, and deployment.
Key Differences -
1. Physical vs. Digital - Conventional engineering creates physical things, while software
engineering builds digital programs.
2. Materials vs. Code - A building needs bricks and cement, but software only needs code
3. Fixed vs. Flexible - A bridge cannot be changed after construction, but software can be
updated anytime.
By: ARMAN ALI
4. Wear & Tear - A machine wears out over time, but software never physically breaks, only
needs updates.
5. Testing Approach - Conventional engineering tests once before construction, but software
is tested multiple times.

Difference Between Conventional Engineering & Software Engineering

❖ Software Quality Attributes & Its Three Dimensions ([Link])
What are Software Quality Attributes?
Software quality attributes are the features that determine how good, reliable, and efficient
a software system is. A high-quality software should be:
1. Fast
2. Easy to use
3. Secure
4. Error-free
5. Maintainable
These attributes ensure that the software meets user expectations and works smoothly in
real-world conditions.
Three Dimensions of Software Quality :
Software quality can be measured in three dimensions, which ensure that the software is
useful, efficient, and error-free.
1. Quality of Design

• Refers to how well the software is planned before development.

• Includes features, user interface, and overall structure.
• A good design ensures the software is easy to use and maintain.
Example: A well-designed e-commerce app has simple navigation, a clean layout, and
smooth checkout.
2. Quality of Conformance
 • Refers to how well the software follows the design plan and meets user
requirements.
• Ensures that developers follow coding standards, fix bugs, and test properly.
• Good conformance means fewer software errors and crashes.
Example: If a food delivery app is designed to send notifications, it should always notify users
when their order is ready.
3. Quality of Performance

• Measures how well the software runs under real conditions.

• Ensures the software is fast, reliable, and efficient.
• Good performance means smooth user experience without delays or failures.
Example: A video streaming app should play videos without buffering, even with many users
online.
Important Software Quality Attributes :

Software Development Life Cycle (SDLC) : ([Link])

What is SDLC?
The Software Development Life Cycle (SDLC) is a step-by-step process that software
engineers follow to plan, create, test, and maintain a software application.
Think of SDLC like building a house:
 1) First, you plan how the house will look.
2) Then, you design the layout.
3) Next, you build the house.
4) You check if everything works properly.
5) Finally, you maintain the house over time.
Similarly, in SDLC, software goes through different phases to ensure it works properly
Phases of SDLC & Their Activities :

1. Requirement Analysis

• The first step is to understand what the software should do.

• Developers talk to clients or users to know their needs.
• A Software Requirement Specification (SRS) document is created, listing all features.
Example: If you are making a food delivery app, you need to know:

• Should it have online payment?

• Should users be able to track their orders?
• Should restaurants have separate accounts
2. Planning

• This phase decides how to build the software.

• Teams decide the budget, technology stack, and timeline.
• A project manager makes a plan for developers.

Example: For an e-commerce website, they may decide to use:

• Frontend: [Link]
• Backend: [Link]
• Database: MongoDB
3. Design
 • In this phase, developers create the software blueprint.
• It includes:
1. UI/UX design (how the app looks).
2. Database design (how data is stored).
3. Software architecture (how different parts connect).
Example: For a social media app, the design will include:
1. Profile page layout
2. Friend request system
3. Message storage

4. Development (Coding)

• This is where programmers write the actual code.

• The software is built feature by feature.
• Backend and frontend developers work together.
Example:
For a ride-sharing app like Uber, developers will:
1. Code the GPS tracking system.
2. Code the payment system.
3. Code the user profile system.
5. Testing

• The software is tested for bugs and errors.

• Testers check if all features are working as expected.
• If bugs are found, developers fix them before release. encrypted properly?
Example:
For an online banking app, testers will check:

• Can users log in successfully?

• Is the money transfer feature working correctly?
• Are passwords
6. Deployment

• The software is released to the users.

• It is hosted on a server or available for download.
• The team monitors the first few weeks for any major problems.
Example: When Instagram launches a new update, it is first tested on a small group of users,
then released to everyone.
SDLC Models :
 • Waterfall Model
• Prototype Model
• Evolutionary Development Model
• Iterative Enhancement Model

Waterfall Model :
What is the Waterfall Model?
The Waterfall Model is a step-by-step process for developing software. In this model, each
phase must be completed before moving to the next phase, just like water flows down in a
waterfall.
Think of it like building a house :
[Link], you plan the house design.
2. Then, you build the foundation.
3. Next, you construct the walls and roof.
4. Finally, you paint and decorate the house.
5. You cannot go back and change the foundation once the roof is built.
Similarly, in the Waterfall Model, each phase is completed before moving to the
next one!
Phases of the Waterfall Model :
1. Requirement Analysis :

• The first step is to understand what the client or user needs.

• Developers write down all the requirements in a document called Software
Requirement Specification (SRS).
• This phase is very important because once it's finalized, changes cannot be made
easily.
Example: For a food delivery app, requirements might be:

• Users should be able to order food online.

• Restaurants should have their own accounts.
• Payments should be done via credit card or UPI.
2. System Design

• The architecture, UI, and database of the software are planned.

• Developers decide which programming language, frameworks, and tools to use.
• The system is designed in two parts:
High-Level Design (HLD): Overall system architecture.
Low-Level Design (LLD): Detailed design of each module. I
Example:
For an e-commerce site, developers will decide:

• Use [Link] for frontend and [Link] for backend.

• Store product details in MongoDB database.
• Create a payment gateway integration.
3. Implementation (Coding) :

• This is the main development phase, where programmers write the actual code.
• Developers follow the design to build the software.
• The code is usually written in modules (small parts) and then combined.
Example:

• For a ride-booking app, developers will:

• Code the GPS tracking system.
• Code the ride-booking feature.
• Code the payment integration.

4. Testing✔

• Before launching, the software is tested for bugs, errors, and performance issues.
• There are different types of testing:
1. Unit Testing (checking each module separately).
2. Integration Testing (checking how modules work together).
3. System Testing (checking the entire software).
Example:
For an online banking app, testers will check:

• Can users log in successfully?

• Is the money transfer feature working correctly?
• Is the app secure from hackers?
5. Deployment

• After testing, the software is released for users.

• It can be hosted on a server or app store.
• Sometimes, a beta version is released first to check for issues.
Example: When WhatsApp launches a new update, it is first tested on a small group of
users, then released to everyone.
6. Maintenance & Updates

• After deployment, developers fix bugs, improve performance, and add new features.
• Software needs regular updates to stay secure and efficient.

Example: Facebook adds new features like: ✔ Dark Mode ✔Reactions (like, love, care, etc.)
✔Faster loading speed

❖Advantages of the Waterfall Model :

• Simple and easy to use Best for small projects.

• Clear structure Each phase is well-defined.
• Good for well-documented projects Works well when requirements don't change.

❖Disadvantages of the Waterfall Model :

• Not flexible Changes are difficult once a phase is completed.

• Testing comes late Bugs are only found after development.
• Not suitable for big projects If requirements change, the whole process must restart.

[Link] Model : ([Link])

What is the Prototype Model?
The Prototype Model is a software development approach where a sample version
(prototype) of the final software is created first. This helps developers and clients
understand how the software will look and work before fully developing it.
Think of it like designing a car:
1. First, a small prototype (sample model) of the car is built.
2. Customers check the design and suggest improvements.
3. The company modifies the design based on feedback.
4. Once everything is finalized, the actual car is manufactured.
Similarly, in software development, a prototype is created, tested, improved, and then the
final software is developed!

Acepted by
customer

[Link] Gathering

• Developers talk to the client to understand their needs.

• A list of features is written down.
• The focus is on basic requirements (not all details).
Example: For a movie streaming app, requirements might be:

• Users should be able to watch movies online.

• The app should suggest popular movies.
• A login system should be included.
2. Quick Design (Develop Prototype)

• Developers make rough sketches of how the software will look.

• The design is not perfect, just an idea to start with.
• A basic version of the software is created.
• It may not have all features, just key functions.
• The prototype is not the final software, just a sample.
Example: For a shopping website, they will design:

• A homepage with product categories.

• A cart page where users add items.
 • A checkout page for payments.
• Browsing restaurants fol.
• But ordering food is not yet available.
3. Customer Feedback

• The client uses the prototype and gives feedback.

• Developers understand what to improve.
Example: A client using a hotel booking app may say:

• "I can't filter hotels by price."

• Developers then add a price filter.
4. Improve Prototype (Refine Requirements)

• Developers modify the prototype based on feedback

• This process repeats until the client is satisfied.
Example: For a music streaming app:

• Users say, "Add a download option."

• Developers add a download feature.
5. Design (Creating the Final Blueprint of the Software)

• Once the prototype is approved, the detailed design of the final software is created.
• This includes technical specifications, database design, and other important details.
Example: For the shopping website, the final design includes:

• A structured homepage, product pages, and checkout page

• Database design for storing user and product data
• Security features to protect user information
At this point, the final blueprint is ready, and coding begins next.
6. Implement (Writing the Actual Code)

• The developers start coding the actual software based on the final design.
• Now, all features are fully developed and functional.
Example: For the shopping website, the developer writes code for:

• A working shopping cart

• A checkout system with payment options
• A user login system
This is the stage where the real software is built.
7. Test (Finding and Fixing Bugs)

• The developed software is tested to check if there are any errors or bugs.
 • This ensures that everything works properly before launching.
Example: For the shopping website, the testing team checks:

• If the payment gateway works correctly

• If users can log in and place orders
• If there are any errors when searching for products
If bugs are found, the developer fixes them before releasing the software.
8. Maintain (Updating and Fixing Issues Over Time)

• Once the software is launched, it needs regular updates and maintenance.

• New features might be added, or old ones might need improvement.
Example: After launching the shopping website, the company may:

• Add new categories like Books and Groceries

• Improve the speed of the website
• Fix any security issues
This maintenance phase continues as long as the software is in use.

[Link] Development Model -

The Evolutionary Development Model is a software development approach where the
software is developed and improved in multiple small versions (iterations) instead of
building it all at once. This model is useful when the requirements are unclear or likely to
change.
In simple words, software evolves step by step by continuously improving and adding new
features based on user feedback.
Two Types of Evolutionary Models -
The Evolutionary Model has two main types:
1. Incremental Development (Iterative Enhancement)- The software is developed part by
part and released in small versions.
2. Spiral Model - The software is developed in a spiral cycle, where each phase improves
upon the last with added features and risk management.

[Link] Enhancement Model : ([Link])

The Iterative Enhancement Model is a software development model where the software is
developed and improved step by step through multiple iterations. Instead of building the
complete software at once, new features are added and refined in different cycles until the
final version is ready.
How Does the Iterative Enhancement Model Work?f
The model follows these steps:
1. Initial Planning (Requirements & Design):

• In the beginning, basic features of the software are planned.

• Only the core functionality is developed in the first iteration.
• The design is not fixed; it can be updated in later iterations.

Key Features of the Iterative Enhancement Model :

• Software is built step by step (not all at once).

• User feedback helps improve each version.
• New features are added in each iteration.
• Existing features are refined without breaking the system.
• Testing happens in every cycle, ensuring a stable product.
Example: Imagine you are developing a To-Do List App.

• First iteration: Users can add and delete tasks (basic functionality).
• No extra features yet like reminders or categories.
2. First Iteration (Basic Version)

• The first version of the software is developed with essential features.

• It is then tested for bugs and performance issues.
 • The software is usable, but improvements are needed.
Example: Your To-Do List App Version 1 is ready, but users request:

• "I need a way to edit tasks."

• "It would be nice to have due dates."
3. Feedback & Improvements

• After the first iteration, user feedback is collected.

• Developers modify and enhance the software based on feedback.
• New features are added without changing the entire system.
Example: In Version 2 of your To-Do List App, you add edit and due date features based on
feedback.
4. Repeating Iterations (More Features & Refinements)

• The process repeats for multiple iterations.

• Each cycle improves the software, making it more complete.
• Developers ensure that new updates do not break old features.
Example:

• Version 3: Add notifications for tasks.

• Version 4: Add task categories and color themes.
• Version 5: Improve UI for better user experience.
5. Final Version (Fully Developed Software)

• After several iterations, the software reaches its final stage.

• It is fully tested, optimized, and ready for release.
• Further changes may still happen in future updates.
Example: Your To-Do List App Final Version now includes:

• Add, delete, edit tasks

• Set due dates and reminders
• Organize tasks by category
• Beautiful Ul with themes

Spiral Life Cycle Model :

• The Spiral Model is a software development process that combines elements of the
Waterfall Model and the Iterative Model. It focuses on risk management and is used
for large, complex projects.
• The Spiral Model is a software development process that follows a repeating cycle
(spiral). In each cycle, we plan, analyze risks, develop, test, and review before
moving to the next version of the software.
 • Each loop (or round) of the spiral means a new version of the software with
improvements. This process continues until the final product is ready.
Phases of the Spiral Model (Step-by-Step) -

1. Planning (What Should We Do?)

This is the first step, where we decide:

• What the software should do (requirements).

• What features are needed in the first version.
• How much time and money the project will take (cost estimation).
Example: If we are building an e-commerce website, we decide:

• The website should have a login system, product listings, and a shopping cart.
• We estimate how long it will take to build
2. Risk Analysis (What Problems Might Happen?)

• Identify possible risks or challenges in the project.

• Find ways to avoid or reduce these risks.
• Take decisions based on risks (choosing the right tools, security measures, etc.).
 ◆ Example: If security is a risk, we may decide to use strong encryption for customer
data and payments.
3. Development & Testing (Build and Check):

• Start coding and developing a small part of the software.

• Test this small part to see if it works correctly.
• Fix any issues found in testing.
◆ Example: We develop and test the login system first, making sure users can register
and log in correctly.
4. Evaluation (Is Everything Good? What Next?)

• Show the developed part to users or clients for feedback.

• If they are happy, move to the next phase.
• If there are problems, go back to planning and improve the design.
◆ Example: If users don't like the login process, we might change it to allow login via Google
or Facebook.
Cycle Repeats Until Software is Complete -
Each time we go through these four steps, the software gets better. The process repeats
multiple times until all features are built and tested.

• First loop → Build the basic version.

• Second loop → Add more features.
• Third loop → Improve design and fix bugs.
• Final loop → Full, tested software is ready for release!

❖Merits (Advantages) of the Spiral Model

• Risk Management - Best for projects where risk is high.

• Customer Feedback - Users give input at every stage.
• Early Detection of Issues - Errors are found and fixed in early stages.
• Flexibility - Changes can be made easily.
• Better Cost Estimation - Since development happens in steps, budgeting is easier.

❖Demerits (Disadvantages) of the Spiral Model

• Expensive - Costs more than other models.

• Time-Consuming - Takes longer due to multiple iterations.
• Complex Process - Not suitable for small projects.
• Expertise Required - Requires skilled developers to manage risks.
Question: Why Spiral Model is Called a Meta model ? (2 marks)

• "Meta" means "higher" or "beyond," so a meta-model is a model that includes other

models.
 • The Spiral Model combines features of different models, like:
• Waterfall Model (step-by-step process)
• Prototype Model (building and improving a small version first)
• Iterative Model (developing in cycles)
• Risk-Driven Approach (analyzing and reducing risks)
Example: Imagine making a new mobile app.
1. First, you plan like the Waterfall Model.
[Link], you build a small prototype like the Prototype Model.
3. You repeat the process to improve it like the Iterative Model.
4. Throughout, you identify risks and solve them.
Since the Spiral Model adapts and includes other models, it is called a Meta-Model.