SOFTWARE DEVELOPMENT LIFE CYCLE

SDLC, or software development life cycle, is a methodology that defines the entire
procedure of software development step-by-step.

 The goal of the SDLC model is to deliver high-quality, maintainable software

that meets the user’s requirements.
 SDLC in software engineering models outlines the plan for each stage so that
each stage of the software development model can perform its task efficiently to
deliver the software at a low cost within a given time frame.

1)REQUIREMENT ANALYSIS:-

During Requirement analysis Business analyst and Project organizer set up a

meeting with the client to gather all the data like

=what the customer wants to build,

who will be the end user,

 what is the objective of the product.

Before creating a product, a core understanding or knowledge of the product is very
necessary.

For Example, A client wants to have an application which concerns money

transactions. In this method, the requirement has to be precise like what kind of operations
will be done, how it will be done, in which currency it will be done, etc.

Stage2: Defining Requirements

Once the requirement analysis is done, the next stage is to certainly represent and document
the software requirements and get them accepted from the project stakeholders.

This is accomplished through "SRS"- Software Requirement Specification document which

contains all the product requirements to be constructed and developed during the project life
cycle.

Stage3 :- System Design

 Develop a blueprint of the system architecture and components.

 This involves creating a detailed design that outlines the database structure, user
interfaces, and system functionalities. It serves as a guide for the developers during the
coding phase.

The main focus of the design phase it to determine how data will flow and be stored.

During System design phase the follwing documents will be prepared

1)the architecture document,

2) critical priority analysis document

3) implementation plan

4) maintenance manual and

5)user manual
 CODING PHASE

1)In this stage of SDLC the actual development starts and the product is built.

2) The programming code is generated as per DDS during this stage. If the design is performed
in a detailed and organized manner, code generation can be accomplished without much
hassle.

3)Developers must follow the coding guidelines defined by their organization and
programming tools like compilers, interpreters, debuggers, etc. are used to generate the code.
Different high level programming languages such as C, C++, Pascal, Java and PHP are used for
coding. The programming language is chosen with respect to the type of software being
developed.

TESTING PHASE

The Testing Phase in the Software Development Life Cycle (SDLC) is

crucial for ensuring the software application meets the required
specifications and functions correctly.
This phase follows the development stage and involves rigorous
evaluation of the software to identify and correct any defects or issues.
The primary objective is to ensure the application works according to the
customer requirements.
During testing, various types of tests are conducted, including unit
testin,, integration testing, system testing, and acceptance testing, to
verify different aspects of the software.

Unit testing
Unit Testingis a method for evaluating software that targets individual
code units or components in isolation. It aims to validate that each
software unit performs as expected, helping developers identify and fix
potential defects before they become more significant problems.

Integration testing is another type of functional software testing that

focuses on the interactions between different modules or components of
a system.
DEPLOYMENT PHASE
The deployment phase in SDLC is the critical process where developed
software is made available to its intended users.
It signifies the cOMBINATION of development and testing team efforts,
transitioning the software into a live environment.
The success of the Depolyment phase is measured by
1-the software's stability
2 performance, and
3user satisfaction in the real world.
A successful deployment is instrumental in minimizing downtime(down
time is the time at which a software will be slow), reducing the risk of
performance issues, and ensuring a positive user experience.
It reflects the software's readiness to meet user expectations and fulfill
its intended purpose, thereby establishing the software's value and
reliability.
 INTRODUCTION TO UML
UML stands for Unified Modeling Langauage

Unified Modeling Language (UML) is a general-purpose modeling

language.
The main aim of UML is to define a standard way to visualize a system
design.
It is quite similar to blueprints used in the field of engineering.
UML is not a programming language, it is rather a visual language.
We need UML (Unified Modeling Language) to visually represent and
communicate complex system designs, facilitating better understanding
and collaboration among stakeholders. Below is why we need UML:
 Complex applications need collaboration and planning from multiple
teams and hence require a clear and concise way to communicate
amongst them.
 Businessmen do not understand code. So UML becomes essential to
communicate with non-programmers about essential requirements,
functionalities, and processes of the system.
 A lot of time is saved down the line when teams can visualize
processes, user interactions, and the static structure of the system.
TYPES OF UML DAIGRAMS
Structural UML Diagrams
Structural UML diagrams are visual representations that depict
the static aspects of a system, including its classes, objects,
components, and their relationships, providing a clear view of the
system’s architecture. Structural UML diagrams include the
following types:
Behavioral UML Diagrams
Behavioral UML diagrams are visual representations that depict
the dynamic aspects of a system, illustrating how objects interact
and behave over time in response to event

OVERVIEW OF SOFTWARE ENGINEERING

1. Software Engineering is the process of designing, developing,
testing, and maintaining software.
2. Software Engineering is a systematic and disciplined
approach to software development that aims to create high-
quality, reliable, and maintainable software.
3. 3.Software engineering includes a variety of techniques,
tools, and methodologies, including requirements analysis,
design, testing, and maintenance.
4. It is a rapidly evolving field, and new tools and technologies
are constantly being developed to improve the software
development process.
5. By following the principles of software engineering and using
the appropriate tools and methodologies, software
developers can create high-quality, reliable, and maintainable
software that meets the needs of its users.
6. Software Engineering is mainly used for large projects based
on software systems rather than single programs or
applications.
7. The main goal of Software Engineering is to develop software
applications for improving quality, budget, and time
efficiency.
8. Software Engineering ensures that the software that has to
be built should be consistent, correct, also on budget, on
time, and within the specified requirements.
 UNIT-II
REQUIREMENT ANALYSYS AND DESIGN
Software Requirements are generally a type of expectation of
user from software product that is important and need to be
fulfilled by software.
Requirement Analysis means to examine something in an
organized and specific manner to know complete details .
Software requirement analysis simply means complete study,
analyzing, describing software requirements so that requirements
that are genuine and needed can be fulfilled to solve problem.
There are several activities involved in Software
requirements analysis . They are
1. Problem Recognition :
The main aim of requirement analysis is to fully understand
main objective of requirement that includes
why it is needed?
Will it be beneficial ?
Does it increase quality of the product?
Does it will have any other effect.
All these points are fully recognized in problem
recognition so that requirements that are essential can be
fulfilled to solve business problems.

2. Evaluation and Synthesis :

Evaluation means judgement about something whether it is
worth or not and
synthesis means to create something.
These are the tasks that are important in the evaluation
and synthesis of software requirement :
 To define all functions of software that necessary.
 To define all data objects that are present externally and
are easily observable.
 To evaluate that flow of data is worth or not.
  To fully understand overall behavior of system that
means overall working of system.

 To define an interface to fully understand how system

interacts with two or more components.
3. Modeling :
After complete gathering of information from above tasks,
functional and behavioral models are established after
checking function and behavior of system using a domain
model that also known as the conceptual model.

4. Specification :
The software requirement specification (SRS) which means to
specify the requirement whether it is functional or non-
functional .

5. Review :
After developing the SRS, it must be reviewed to check
whether it can be improved or not .
USE CASE and Scenarios
A use case is a description of the different ways that a user can
interact with an application or product.
They define the various external entities that exist outside the
system, as well as the specific interactions they have with the
system.
What is the Purpose of a Use Case? Benefits & Importance
The major benefits that use cases provide are in the planning
stage of development. Steps like requirements gathering, defining
scope, and roadmap creation are all improved through the clarity
that these use cases bring.
They also allow the team to identify the best possible outcome
scenario, accurately depicting the intended design and use of the
system..
How to Write a Use Case
Writing a use case can be started with three basic steps or
questions:
 Who is going to use the software?
 For what purpose they use the software for?
 How are they going to use it?
SCENARIO
The main difference between a use case and a scenario is
that a use case describes for what purpose a user interacts with a
system while a scenario describes how the system responds to
that interaction
A scenario is a sequenceof steps describing an interaction between a
system and a user.
So if we have a Web-based on-line store, we might have a
Buy a Product scenario that would look like this

The customer browses the catalog and adds desired items to the shopping
basket.When the customer wishes to pay, the customer describes the
shipping and creditcard information and confirms the sale. The system
checks the authorization onthe credit card and confirms the sale both
immediately and with a follow-up email.
This scenario is one thing that can happen. However, the credit card
authorization might fail, and this would be a separate scenario. In another
case, you may havea regular customer for whom you don’t need capture
the shipping and credit cardinformation, and this is a third scenario.

A use case is a set of scenarios tied together by a common user goal

USE CASE DIAGRAM
A Use Case Diagram in Unified Modeling Language (UML) is a
visual representation that illustrates the interactions between
users (actors) and a system.
It captures the functional requirements of a system, showing how
different users engage with various use cases, or specific
functionalities, within the system.
Use case diagrams provide a high-level overview of a system’s
behavior, making them useful fordevelopers, and analysts to
understand how a system is intended to operate from the user’s
perspective, and how different processes relate to one another.
They are crucial for defining system scope and requirements.
OOAD(Object Oriented Analysis and Design)

Object-Oriented Analysis and Design (OOAD) is a way to design software by

thinking of everything as objects similar to real-life things.

In OOAD, we first understand what the system needs to do, then identify key
objects, and finally decide how these objects will work together. This approach
helps make software easier to manage, reuse, and grow.

Object-Oriented Analysis

Object-Oriented Analysis (OOA) is the process of understanding and analyzing the

system requirements by looking at the problem scenario in terms of objects.

 These objects represent real-world entities or concepts that are relevant to

the system being developed.

 During OOA, the goal is to identify the objects, their attributes, behaviors,
and relationships, without focusing on how the system will be implemented.

For example: Lets say you’re building a game:

 OOA helps you figure out all the things you need to know about the game
world – the characters, their features, and how they interact.

 It’s like making a map of everything important.

 OOA also helps you understand what your game characters will do. It’s like
writing down a script for each character.

 Every program has specific tasks or jobs it needs to do. OOA helps you list
and describe these jobs.

 In our game, it could be tasks like moving characters or keeping score. It’s
like making a to-do list for your software.
 OOA is smart about breaking things into different parts. It splits the job into
three categories: things your game knows, things your game does, and how
things in your game behave.

1. The Subsystem Layer: It represents the subsystem that enables software to

achieve user requirements and implement technical frameworks that meet
user needs.

2. The Class and Object Layer: It represents the class hierarchies that enable
the system to develop using generalization and specialization. This layer also
represents each object.

3. The Message Layer: This layer deals with how objects interact with each
other. It includes messages sent between objects, method calls, and the flow
of control within the system.

4. The Responsibilities Layer: It focuses on the responsibilities of individual

objects. This includes defining the behavior of each class, specifying what
each object is responsible for, and how it responds to messages.
Benefits of Object-Oriented Analysis and Design(OOAD)

 It increases the modularity and maintainability of software by encouraging

the creation of tiny, reusable parts that can be combined to create more
complex systems.

 It provides a high-level, abstract representation of a software system, making

understanding and maintenance easier.

 It promotes object-oriented design principles and the reuse of objects, which

lowers the amount of code that must be produced and raises the quality of
the program.

 Software engineers can use the same language and method that OOAD
provides to communicate and work together more successfully in groups.

 It can assist developers in creating scalable software systems that can adapt
to changing user needs and business demands over time.

Design Patterns

Software design patterns are important tools developers, providing proven

solutions to common problems encountered during software development.
Developers can create more robust, maintainable, and scalable software systems
by understanding and applying these patterns.

Reusable solutions for typical software design challenges are known as design
patterns. Expert object-oriented software engineers use these best practices to
write more structured, manageable, and scalable code. Design patterns provide a
standard terminology and are specific to particular scenarios and problems. Design
patterns are not finished code but templates or blueprints only.

Key Characteristics of Design Patterns

  Reusability: Patterns can be applied to different projects and problems,
saving time and effort in solving similar issues.

 Standardization: They provide a shared language and understanding among

developers, helping in communication and collaboration.

 Efficiency: By using these popular patterns, developers can avoid finding the
solution to same recurring problems, which leads to faster development.

 Flexibility: Patterns are abstract solutions/templates that can be adapted to

fit various scenarios and requirements.

 Types of Software Design Patterns

 There are three types of Design Patterns:

 Creational Design Pattern

 Structural Design Pattern

 Behavioral Design Pattern

 1. Creational Design Patterns
 Creational Design Patterns focus on the process of object creation or problems related to object creation. They help in
making a system independent of how its objects are created, composed and represented.

Types of Creational Design Patterns:

 Factory Method Design Pattern

o This pattern is typically helpful when it's necessary to separate the

construction of an object from its implementation.

o With the use of this design pattern, objects can be produced without
having to define the exact class of object to be created.

 Abstract Factory Method Design Pattern

 o Abstract Factory pattern is almost similar to Factory Pattern and is
considered as another layer of abstraction over factory pattern.

o Abstract Factory patterns work around a super-factory which creates

other factories.

 Singleton Method Design Pattern

o Of all, the Singleton Design pattern is the most straightforward to

understand.

o It guarantees that a class has just one instance and offers a way to
access it globally.
 2. Structural Design Patterns
 Structural Design Patterns solves problems related to how classes
and objects are composed/assembled to form larger structures which
are efficient and flexible in nature. Structural class patterns use
inheritance to compose interfaces or implementations .
Types of Structural Design Patterns:

 Adapter Method Design Pattern

o The adapter pattern convert the interface of a class into another

interface clients expect.

o Adapter lets classes work together that couldn’t otherwise because of

incompatible interfaces.

 Bridge Method Design Pattern

o The bridge pattern allows the Abstraction and the Implementation to

be developed independently.

o The client code can access only the Abstraction part without being
concerned about the Implementation part.

 Composite Method Design Pattern

o As a partitioning design pattern, the composite pattern characterizes a
collection of items that are handled the same way as a single instance
of the same type of object.

o The intent of a composite is to “compose” objects into tree structures

to represent part-whole hierarchies.