Introduction to Software Development

Software Development
Software engineering is nothing but a disciplined approach to develop software.
Now we will look at some of the activities involved in the course of software
development.
The activities involved in software development can broadly be divided into two
major categories.
first is construction and second is management.
The construction activities are those that are directly related to the construction or
development of the software.

While the management activities are those that complement the process of
construction in order to perform construction activities smoothly and
effectively.

A greater detail of the activities involved in the construction and management

categories is presented below.

Construction
The construction activities are those that directly related to the development of
software,
e.g. gathering the requirements of the software, develop design, implement and test
the software etc. Some of the major construction activities are listed below.

 Requirement Gathering
 Design Development
 Coding
 Testing

Management
Management activities are kind of umbrella activities that are used to smoothly and
successfully perform the construction activities e.g. project planning, software
quality assurance etc. Some of the major management activities are listed below.
Management activities support construction by helping it run smoothly and
successfully.

 Project Planning and Management

 Configuration Management
 Software Quality Assurance
 Installation and Training

Management
Management activities protect and guide the construction process, ensuring it runs
smoothly. As shown in Figure 1, these activities surround the construction work.
They focus on managing the process, not on building itself.

As mentioned earlier, management activities are like a protective cover around the
construction activities, making sure the construction process goes smoothly. This
idea is shown in Figure 1, where you can see that construction is surrounded by
management activities. This means that all construction work is guided by certain
rules and processes. These rules are about managing the construction work, not the
actual building process.

Software Engineering Framework

Any Engineering approach must be founded on organizational commitment to
quality.
That means the software development organization must have special focus on
quality
while performing the software engineering activities. Based on this commitment to
quality by the organization, a software engineering framework is proposed that is
shown
in figure 2.

A Software Engineering Framework is a set of guidelines and tools that help

organizations create high-quality software in an organized and efficient way. It
includes steps to follow, methods to use, and tools to support the process.

The major components of this framework are described below.

Quality Focus: The framework is based on the organization’s promise to deliver

good-quality software. This means setting clear steps to develop the software
efficiently and making sure quality is the main priority throughout the process.

Processes: The processes are set of key process areas (KPAs) for effectively
manage and deliver quality software in a cost effective manner.
The processes define the tasks to be
performed and the order in which they are to be performed. Every task has some
deliverables and every deliverable should be delivered at a particular milestone.

Processes: Processes are important steps that help manage and deliver quality
software in an efficient and cost-effective way. They outline the tasks that need to
be done and the order in which to do them. Each task has specific results, and these
results must be completed at certain points in the project.

Methods: Methods provide the technical “how-to’s” to carry out these tasks. There
could
be more than one technique to perform a task and different techniques could be
used in
different situations.

Methods are the "how-to’s" or techniques used to complete the tasks. There can be
different ways to do the same task, and different methods may be used depending
on the situation.
Tools: Tools provide automated or semi-automated support for software processes,
methods, and quality control.

Tools: Tools are programs or systems that help make the software development
process faster and easier by automating some tasks and checking quality.

Software Development Loop

Lets now look at software engineering activities from a different perspective.
Software
development activities could be performed in a cyclic and that cycle is called
software
development loop.

Software development activities can be done in a repeated cycle, and this cycle is
called the software development loop. This means the process of developing
software is done in steps that are repeated until the software is complete and
working properly.

The major stages of software development loop are described below.

Problem Definition: In this stage we determine what is the problem against which
we are
going to develop software. Here we try to completely comprehend the issues and
requirements of the software system to build.

Problem Definition: In this stage, we figure out what problem the software will
solve. We make sure we understand exactly what is needed for the software before
we start building it

Technical Development: In this stage we try to find the solution of the problem on
technical grounds and base our actual implementation on it. This is the stage where
a new
system is actually developed that solves the problem defined in the first stage.
Solution Integration: If there are already developed system(s) available with
which our
new system has to interact then those systems should also be the part of our new
system.
All those existing system(s) integrate with our new system at this stage.

Technical Development: In this stage, we figure out how to solve the problem
using technology and start building the software to do that.

Solution Integration: If there are other systems that our new software needs to
work with, we make sure they connect and work together properly.

Status Quo: After going through the previous three stages successfully, when we
actually
deployed the new system at the user site then that situation is called status quo. But
once
we get new requirements then we need to change the status quo.

Status Quo: After completing the previous stages and successfully installing the
new system for the user, this situation is called the "status quo." But once we
receive new requirements, we have to update or modify the current system to
meet those new needs.
After receiving new requirements, we repeat all the steps in the software
development loop. The software created through this process is flexible, meaning
it can be easily updated and integrated with existing systems.

Software Construction
Here once again look at the construction activities of the software from a different
perspective. This section provides with a sequence of questions that have to answer
in
different stages of software development.

1. What is the problem to be solved?

2. What are the characteristics of the entity that is used to solve the problem?
3. How will the entity be realized?
4. How will the entity be constructed?
5. What approach will be used to uncover errors that were made in the design and
construction of the entity?
6. How will the entity be supported over the long term, when users of the entity
request
corrections, adaptations, and enhancements?
Software Construction
This section looks at building software from a different point of view. It asks a
series of questions that need to be answered at different stages of software
development:
1. What problem needs to be solved?
What is the main issue the software will fix?
2. What are the features of the software?
What qualities or parts of the software will help solve the problem?
3. How will the software be built?
What steps will we take to create the software?
4. How will the software be constructed?
How exactly will we make the software, and what methods will we use?
5. How will we find and fix mistakes?
How will we check for errors in the design and building of the software?
6. How will the software be supported over time?
How will we keep the software updated and fix any issues after it is used by
people?

Software Engineering Phases

There are four basic phases of software development that are shown in Figure 4.

Vision: In this step, we figure out why we are building the software and what
business goals we want to achieve with it.

Definition: Here we actually realize or automate the vision developed in first

phase. Here we determine what are the activities and things involved.
Definition: In this phase, we turn the ideas from the first phase into action by
planning what needs to be done.

Development: Here, we decide how the system will be designed, how it will be
built, and how we will test it to make sure it works.

Maintenance: This phase is important because it involves making changes to the

system, either to improve it or fix any problems that come up.
Maintenance
Correction, adaptation, enhancement
Maintenance means fixing problems, making updates, and improving the
software over time. For most large software systems, the cost of maintaining the
software is usually higher than the cost of building it, often 2 to 3 times more
expensive.

Software engineering
The term is made up of two words: software and engineering.
Software is more than just a program. A program is executable code that
performs a specific task. Software is a collection of executable code, libraries, and
documentation. When software is created for a specific purpose, it is called a
software product.
Engineering, on the other hand, is the process of developing products using clear,
scientific principles and methods.
Software engineering is a field of engineering focused on creating software
products using clear methods, principles, and steps. The goal is to produce
software that is both efficient and reliable.
Definitions:
 IEEE defines software engineering as:
1. Using a careful and organized approach to develop, run, and
maintain software. In simple terms, it means applying engineering to
create software.
2. Studying the methods mentioned above.
  Fritz Bauer, a German computer scientist, defines software engineering as:
 Using strong engineering principles to create software that works well, is
reliable, and runs smoothly on real machines, all while being cost-effective.

Software Evolution
Software evolution is the process of developing and improving a software product
using software engineering methods. This includes both the first development of
the software and its maintenance and updates until it fully meets the required
goals.

Software evolution starts with gathering requirements. Then, developers create a

prototype and share it with users for feedback. Based on this feedback, the
software is updated and improved until it meets the desired goals.
Even after the software is finished, changing technology and new requirements
mean the software must keep updating. Instead of starting over, the best and
most cost-effective solution is to update the existing software to meet the new
needs.
Software Evolution Laws
Lehman described three types of software based on how they change:
1. S-type (Static-type): Simple software that doesn’t change much. The
solution is clear before coding. This is a software, which works strictly
according to defined specifications and solutions.
Example: A calculator.
 2. P-type (Practical-type): Software that evolves as it is used. The solution
isn’t obvious at first.
Example: A video game.
3. E-type (Embedded-type): Software that changes often due to real-world
factors like laws or taxes.
4. E-type (Embedded-type): This software is designed to work closely with
real-world situations, like changes in laws or taxes. It evolves often to adapt
to these changes.
Example: Online trading software.

E-Type Software Evolution Laws

Lehman’s eight laws for E-Type software:
1. Continuing Change: E-type software needs to keep changing to fit real-
world updates, or it will stop being useful.
2. Increasing Complexity: As E-type software grows, it can get more
complicated unless we work to keep it simple.
3. Conservation of Familiarity: We must remember how and why the
software was made to help with future updates.
4. Continuing Growth: The software needs to grow in size and function to
keep up with changes in the business it’s meant to support.
5. Reducing Quality: The software can lose quality if it's not properly
maintained and updated.
6. Feedback Systems: E-type software uses feedback from different levels,
and we must manage it carefully to improve the software.
7. Self-Regulation: The process of evolving E-type software works naturally
and follows a steady pattern.
8. Organizational Stability: The overall amount of work in the software
system stays steady as it continues to evolve.
Software Paradigms
Software paradigms are the methods and approaches used to design and develop
software. Many different methods are available today, and they are part of the
broader software engineering process. These methods can be grouped into
categories, each fitting within the other:

Programming paradigm is a part of the Software design paradigm, which in turn

is a part of the Software development paradigm.
In simple terms, programming is one part of designing software, and designing
software is one part of the overall process of developing software

Software Development Paradigm

The Software Development Paradigm is a method used to build software by
applying engineering principles. It includes:
It consists of – Requirement gathering Software design Programming
1. Requirement Gathering: Finding out what the users need from the
software.
2. Software Design: Planning how the software will work and be structured.
3. Programming: Writing the code to make the software work.
In simple terms, it’s the approach used to develop software step by step, making
sure it meets users' needs.

Software Design Paradigm

The Software Design Paradigm is part of the software development process and
includes: Design
Maintenance Programming
The Programming Paradigm
focuses on the coding part of software development. This includes –
Coding
Testing
Integration
Need of Software Engineering
Software engineering is needed because user needs and the environment change
fast, and it helps manage these changes in software.
1. Large Software: As software gets bigger, it's harder to manage. Software
engineering helps keep it organized and structured.
2. Scalability: Without engineering methods, it’s easier to build new software
from scratch than to improve existing software.
3. Cost: Hardware costs have dropped, but without proper methods, software
can remain expensive to develop.
4. Dynamic Nature: Software needs to adapt to changes. Software
engineering helps update and improve software regularly.
5. Quality Management: Good software engineering processes ensure better
quality software.
In short, software engineering helps make software bigger, cheaper, adaptable,
and of higher quality.
 Characteristics of Good Software:
1. Operational: How well the software works:
o Budget, usability, efficiency, correctness, functionality, dependability,
security, safety.
2. Transitional: How well the software can be moved or adapted:
o Portability, interoperability, reusability, adaptability.
3. Maintenance: How easily the software can be updated or fixed:
o Modularity, maintainability, flexibility, scalability.
In short, good software is efficient, reliable, easy to adapt, and easy to maintain.

Nature of software
Computer Science
• Focus: Creating and improving computer programs and systems.
Work: Building software, websites, and other digital tools.
• Skills Needed: Math, problem-solving, understanding how computers work,
and organizing data.
• Specializations: Smart computers (AI), teaching computers to learn
(machine learning), protecting data (cybersecurity), and studying how computers
solve problems (computational theory).
Software Engineering
• Focus: Making sure coding follows best practices and works as expected.
• Work: Writing software, fixing errors, and launching programs.
• Skills Needed: Problem-solving, logical thinking, math, and persistence.
Information Technology (IT)
• Focus: Keeping computer systems, networks, and databases running
smoothly.
• Work: Setting up, managing, and fixing computer programs and systems.
• Skills Needed: Organizing data, good communication, teamwork, and
managing projects.
• Applications: Helping businesses use technology effectively.
Key Characteristics of Software
• Intangible: Software is not a physical object; it cannot be touched or felt.
• Evolvable: Software can be easily updated and improved over time.
• Complexity: Software systems can be complicated because different parts
depend on each other.
• Perishability: Software doesn’t wear out, but it can become outdated.
• Scalability: Software can handle more users or tasks without physical
limitations.
Definition of Software
Software is a set of programs, data, and instructions that help a computer
perform specific tasks or provide services.
Components:
 Programs (code)
 Data (processed by programs)
 Documentation (manuals, user guides)
Differences Between Software and Hardware
• Wear and Tear: Hardware breaks down over time, but software does not
physically wear out.
• Design and Development: Creating software requires logical thinking and
problem-solving, while hardware involves physical construction.
• Replication: Software can be copied and shared easily at little to no cost,
unlike hardware, which must be physically manufactured.
More Differences Between Software and Hardware
• Tangibility: Hardware is a physical object you can touch, while software
exists as code and data.
• Upgradability: Software can be updated easily, while upgrading hardware
often requires replacing parts.
• Functionality: Hardware provides the foundation (e.g., computers, servers),
while software tells the hardware what to do.
• Dependency: Software needs hardware to run, but hardware can exist
without software (though it won’t function as a computer).
• Failure Modes: Hardware fails due to physical damage or aging, while
software issues are usually caused by bugs or compatibility problems.

Types of Software
• System Software: Includes operating systems (like Windows, macOS, Linux)
and utility programs that help manage a computer.
• Application Software: Programs for users, such as word processors, games,
and business applications.
• Embedded Software: Built into devices like home appliances, cars, and
medical equipment to control their functions.
• Web-Based Software: Runs on the internet and is accessed through a
browser (e.g., Google Docs, online banking).
• AI/ML Software: Uses artificial intelligence and machine learning to
improve and adapt over time (e.g., chatbots, recommendation systems).
Key Challenges in Software Development
• Requirements Volatility: Software needs and goals often change during
development.
• Quality Assurance: Making sure the software works correctly and meets
user expectations.
• Scalability and Performance: Ensuring the software runs efficiently as more
users or data are added.
• Security: Protecting software and user data from cyber threats and attacks.

Software Development Concepts principle

• Systematic Approach: Structured methods like Agile and Waterfall guide
the development process.
o Agile: Flexible and iterative, allowing feedback and changes during the
project.
o Waterfall: A step-by-step approach where each phase is completed before
moving to the next, with little room for changes during development.
• Abstraction and Modularity: Breaking down complex systems into simpler,
manageable parts to make development easier.
• Verification and Validation: Ensuring the software works as intended and
meets all requirements.
• User-Centric Design: Focusing on making software easy to use and
providing a good experience for the user.

Systematic Approach
A systematic approach means following a clear process to develop software. Two
common methods are

• Agile: A flexible method where the project is done in small steps. You get
feedback often and can make changes anytime.
• Waterfall: A step-by-step method where you finish one phase before
starting the next. It’s harder to make changes once you move forward

Incremental Process Model

The Incremental Process Model is also known as the Successive version model.
What is the Incremental Process Model?

"The incremental model in software development is a way of building software

step by step. Instead of creating the entire system all at once, the project is
divided into smaller parts called increments. Each part adds new features, and the
software improves over time. This allows a working version of the software to be
available early, so users can provide feedback as development continues. This
method helps developers make changes and improvements, leading to a better
final system."

The incremental model is a simpler version of the waterfall model. It breaks the
project into smaller cycles that include planning, designing, developing, and
testing, with each cycle creating a new version of the software. Each new version
improves on the previous one.
First, a basic version of the system with just a few features is built and given to
the customer. Then, more versions are created and delivered to the customer
until the final version of the system is ready.

A, B, and C are parts of the software that are developed and delivered in stages.
 Phases of incremental model
The software requirements are first divided into smaller parts, which are built and
delivered step by step.

In Requirement Analysis,
In Requirement Analysis, the plan is made only for the next increment, not for the
entire project. This makes it easier to adjust the software based on the customer's
needs.

Design & Development:

At any given time, the plan is focused only on the next increment, not a long-term
plan. This makes it easier to adjust the software to meet customer needs.
The development team first works on building the core features of the system,
which don’t depend on other features. Once the core features are complete, they
are improved and expanded by adding new functions in each new version.
Each version is typically developed using an iterative waterfall model.
Deployment and Testing:
After gathering and understanding the requirements, the work is divided into
different versions, starting with version 1. Each new version is developed and
tested to make sure it works properly. As each new version is ready, it is deployed
at the customer’s site. During development and testing, the product is checked to
make sure it works as expected.

Implementation:
When the final version is ready, it’s fully set up at the customer’s site for them to
use.
In implementation After the last version (version n), it is now deployed at the
client site.
Types of Incremental Model
1. Staged Delivery Model
2. Parallel Development Model
Staged Delivery Model
Construction of only one part of the project at a time.
Building one part of the project at a time.

Parallel Development Model: Different parts of the system are developed at the
same time. This can reduce the overall development time (Time to Market) if
there are enough resources available.
When to use the Incremental Process Model

Use the Incremental Process Model when:

 Funding, schedule, risk, or early benefits are important.
 Requirements are clear from the start.
 Projects have long development times.
 Working with new technology.
 Reducing errors by testing core modules early.
 Breaking tasks into smaller parts.
 Lower initial delivery costs.
 Deploying resources gradually.
 Good planning and design are required.
 Total cost is not lower.
 Clear module interfaces are required.

Characteristics of the Incremental Process Model:

  The system is built in smaller parts.
 Each part is built one after the other to make the complete system.
 The most important requirements are done first.
 Once a part's requirements are decided, they don’t change.
Advantages of the Incremental Process Model:
 Software is developed quickly.
 Clients have a clear idea of the project.
 Changes can be made easily.
 Helps manage risks due to its iterative nature.
 Adjusting scope and requirements is flexible and cheaper.
 It’s less expensive compared to other models.
 Identifying errors is easier.

Disadvantages of the Incremental Process Model:

 Requires a skilled team and careful planning.
 Continuous iterations can increase costs.
 Problems may arise in system design if all requirements aren't gathered
upfront.
 Each iteration is separate and doesn’t always connect smoothly to the next.
 Fixing an issue in one part can be time-consuming if it affects all parts.