Phases of the Software Development Life Cycle

Following are the stages that most SDLC frameworks have in common:

1. Planning & Analysis

The first phase of the SDLC is the project planning stage where you are gathering business
requirements from your client or stakeholders. This phase is when you evaluate the
feasibility of creating the product, revenue potential, the cost of production, the needs of the
end-users, etc.
To properly decide what to make, what not to make, and what to make first, you can
use a feature prioritization framework that takes into account the value of the
software/update, the cost, the time it takes to build, and other factors. Once it is decided
that the software project is in line with business and stakeholder goals, feasible to create, and
addresses user needs, then you can move on to the next phase.

2. Define Requirements
This phase is critical for converting the information gathered during the planning and
analysis phase into clear requirements for the development team. This process guides the
development of several important documents: a software requirement specification (SRS)
or product specification, a Use Case document, and a Requirement Traceability Matrix
document.

3. Design
The design phase is where you put pen to paper so to speak. The original plan and vision
are elaborated into a software design document (SDD) that includes the system design,
programming language, templates, platform to use, and application security measures. This
is also where you can flowchart how the software responds to user actions.
In most cases, the design phase will include the development of a prototype model.
Creating a pre-production version of the product can give the team the opportunity to
visualize what the product will look like and make changes without having to go through the
hassle of rewriting code.

4. Development
The actual development phase is where the development team members divide the project
into software modules and turn the software requirement into code that makes the product.
This SDLC phase can take quite a lot of time and specialized development tools
important to have a set timeline and milestones so the software developers understand the
expectations and you can keep track of the progress in this stage.
In some cases, the development stage can also merge with the testing stage where
certain tests are run to ensure there are no critical bugs.
Keep in mind, different types of product development software will have different specialties

5. Testing

important to have your quality assurance team perform validation testing to make sure it is
so help hash
out any major user experience issues and security issues.
In some cases, software testing can be done in a simulated environment. Other
simpler tests can also be automated.

The types of testing to do in this phase:

• Performance testing: Assesses the software's speed and scalability under different
conditions
• Functional testing: Verifies that the software meets the requirements
• Security testing: Identifies potential vulnerabilities and weaknesses
• Unit-testing: Tests individual units or components of the software
• Usability testing: Evaluates the software's user interface and overall user experience
• Acceptance testing: Also termed end-user testing, beta testing, application testing,
or field testing, this is the final testing stage to test if the software product delivers
on what it promises

6. Deployment
During the deployment phase, your final product is delivered to your intended user. You can
automate this process and schedule your deployment depending on the type. For example, if
you are only deploying a feature update, you can do so with a small number of users (canary
release). If you are creating brand-new software, you can learn more about the
different stages of the software release life cycle (SRLC).
7. Maintenance

the waterfall structure of the software development process. However, the industry is
moving towards a more agile software development approach where maintenance is only a
stage for further improvement.
In the maintenance stage, users may find bugs and errors that were missed in the earlier
testing phase. These bugs need to be fixed for better user experience and retention. In some
cases, these can lead to going back to the first step of the software development life cycle.
The SDLC phases can also restart for any new features you may want to add in your next
release/update.

Software Design
Software design is a method that converts user requirements into a suitable form for the
programmer to employ in software coding and implementation. It is concerned with
converting the client's requirements as defined in the SRS (Software Requirement
Specification) document into a form that can be easily implemented using a programming
language. A good software designer needs to have knowledge of what software engineering is.
The software design phase is the first step in the SDLC (Software Development Life
Cycle) that shifts the focus from the problem domain to the solution domain. In software
design, the system is viewed as a collection of components or modules with clearly defined
behaviors and bounds.
Objectives of Software Design
1. Correctness: A good design should be correct, which means that it should correctly
implement all of the system's features.
2. Efficiency: A good software design should consider resource, time, and cost
optimization parameters.
3. Understandability: A good design should be easy to grasp, which is why it should be
modular, with all parts organized in layers.
4. Completeness: The design should include all components, such as data structures,
modules, and external interfaces, among others.
5. Maintainability: A good software design should be flexible when the client issues a
modification request.
Levels of Software Design
1.Architectural Design
A system's architecture can be defined as the system's overall structure and how that
structure offers conceptual integrity to the system. The architectural design characterizes the
software as a system with numerous interconnected components. The designers acquire an
overview of the proposed solution domain at this level.

2.High-level Design
The high-level design deconstructs the architectural design's 'single entity-multiple
component' notion into a less abstract perspective of subsystems and modules, depicting their
interaction with one another. High-level design is concerned with how the system and its
components can be implemented as modules. It recognizes the modular structure of each
subsystem, as well as their relationship and interaction with one another.

3.Detailed Design
After the high-level design is completed, the detailed design begins. Each module is
extensively investigated at this level of software design to establish the data structures and
algorithms to be used. Finally, a module specification document is used to document the
stage's outcome. It defines the logical structure of each module as well as its interfaces with
other modules.

Software Design Concepts

Abstraction
The primary purpose of abstraction is to deal with complexity by concealing internal details
from the user. This allows the user to build more complicated logic on top of the offered
abstraction without having to understand or even consider all the hidden complexity.
Modularity
It refers to breaking a system or project into smaller sections to lessen the system's or project's
complexity. Similarly, modularity in design refers to the division of a system into smaller
elements that can be built independently and then used in multiple systems to execute different
purposes. Sometimes to deal with Monolithic software, which is difficult to grasp for software
engineers, it is required to partition the software into components known as modules. As a
result, modularity in design has become a trend that is also essential.
Refinement
It means removing any impurities and improving the quality of something. The software
design refinement idea is a process of building or presenting the software or system in a
detailed manner, which implies elaborating on a system or software. In addition, refinement is
essential for identifying and correcting any possible errors.
Design Patterns
A Software Design Pattern is a general, reusable solution to a commonly occurring problem
within a given context in software design. They are templates to solve common software
engineering problems, representing some of the finest practices experienced object-oriented
software engineers utilize. A design pattern systematically describes and explains a general
design that handles a recurring design challenge in object-oriented systems. It discusses the
problem, the remedy, when to use it, and the repercussions. It also provides implementation
guidance and examples.
Information/Data Hiding
Simply put, information hiding implies concealing information so that an unauthorized entity
cannot access it. In software design, information hiding is accomplished by creating modules
in such a way that information acquired or contained in one module is concealed and cannot
be accessible by other modules.
Refactoring
Refactoring is the process of reorganizing code without affecting its original functionality.
Refactoring aims to improve internal code by making modest changes that do not affect the
code's exterior behaviour. Computer programmers and software developers refactor code to
improve the software's design, structure, and implementation. As a result, Refactoring
increases code readability while decreasing complications. Refactoring can also assist
software engineers in locating faults or vulnerabilities in their code.

Software Design Document (SDD)

A software design document, is basically a whole blueprint for creating any software. The
software design document outlined how the final software will function and how the team will
work, deadline to complete the task.
Constructing a software design document before coding any project that will take more
than a month is necessary as it will gives you an idea how much time the project will take and
how the process will go in long run. It also tells the work division among team members and
need of number of team members.
A good software design document is dynamic in nature. It is not something that can be
constant for all software problems.

Benefits of Software Design Document:

1. Before coding, team and stakeholders or clients can clarify the expectations for the
project by developing a software design document.
2. It can speed up the coding process.
3. Before creating any code, you must go through the complete system architecture to
construct a software design document.
4. It acts as a centralized document explaining features, dependencies, and other
essential bits of information
.
How to create a software design document
While creating a software design document, few things need to take under
consideration are:
1. The wordings of the software design document must be simple and clear. Keep the
phrases short and include bullet points where applicable.
2. A good software design document have images, charts, flowcharts to make the
design attractive and real.
3. Keep your software design document updated. If your project gets delayed due to
any reason, then you must mention it in software design document. The need of
updation comes from the fact that team members refer to the Software design
document frequently as the project advances.

Different types of software design/model:

1. Level-oriented design: There are two general strategies:
a. Stepwise refinement: The first strategy starts with a general definition of a
solution to the problem. Then the detailed solution to the problem is obtained
through a step-by-step process.
b. Design by composition: The other strategy is to start with a basic solution to the
problem and through a process of modelling the problem, build up or extend the
solution by adding additional features.
2. Data flow-oriented design: The characteristics of information flow is used to derive
program structure. An importance is given to the processing or operations performed on
the data. Design is information-driven. Example is Data Flow Diagram.
3. Data structure-oriented design: This approach uses the data structures of the input data,
internal data (Example: DB) and output data to develop software. The structure of
information has an important impact on the complexity and efficiency of algorithms
designed to process information.
This design is best suited in applications that have a well-defined, hierarchical
structure of information.
4. Object-oriented design: It is based on the concepts of objects, and classes and members.
The object consists of a private data structure and related operations that may transform
the data structure.