Software Engineering

● Software Engineering is a framework for building software and is an engineering approach to

software development. Software programs can be developed without S/E principles and methodologies
but they are indispensable if we want to achieve good quality software in a cost effective manner.
Software is defined as:
Instructions + Data Structures + Documents

● Engineering is the branch of science and technology concerned with the design, building, and use of
engines, machines, and structures. It is the application of science, tools and methods to find cost effective
solution to simple and complex problems.
● SOFTWARE ENGINEERING is defined as a systematic, disciplined and quantifiable approach for the
development, operation and maintenance of software.
● The Evolving role of software
The dual role of Software is as follows:
1. A Product- Information transformer producing, managing and displaying information.
2. A Vehicle for delivering a product- Control of computer(operating system),the communication of
information(networks) and the creation of other programs.

Characteristics of software:
• Software is developed or engineered, but it is not manufactured in the classical sense.
• Software does not wear out, but it deteriorates due to change.
• Software is custom built rather than assembling existing components.
SOFTWARE ENGINEERING - A LAYERED TECHNOLOGY

1. Quality Focus:
○ Quality is the bedrock of software engineering. It encompasses reliability,
performance, security, and maintainability.
○ Engineers strive to create high-quality software that meets user needs
and adheres to industry standards.
○ Techniques like testing, code reviews, and continuous
integration contribute to quality assurance.
2. Process:
○ The process layer provides the foundation for software engineering. It defines how
software is developed, managed, and maintained.
○ Common process models include the Waterfall model, Agile methodologies (like Scrum and Kanban), and DevOps practices.
○ Each process model has its own set of activities, phases, and artifacts.
3. Methods:
○ Methods offer technical guidance on building software. They answer the “how-to” questions.
○ Examples of methods include:
■ Requirements Engineering: Gathering and documenting user needs.
■ Design Patterns: Reusable solutions to common design problems.
■ Object-Oriented Analysis and Design (OOAD): Creating models using UML (Unified Modeling Language).
■ Testing Techniques: Unit testing, integration testing, and system testing.
■ Code Refactoring: Improving code without changing its external behavior.
4. Tools: Tools provide support to methods. They can be manual, semi-automatic, or automatic. Examples of software
engineering tools:

■ Integrated Development Environments (IDEs): Visual Studio Code, PyCharm, Eclipse.

■ Version Control Systems (VCS): Git, SVN.
■ Automated Testing Frameworks: JUnit, pytest.
■ Build Tools: Gradle, Maven.
■ Project Management Tools: Jira, Trello.
Software Development
Software Development is defined as the process of designing, creating, testing, and maintaining computer
programs and applications. This diverse field combines creativity, engineering expertise, and problem-solving
abilities to produce software that satisfies particular requirements and goals. Software developers, also known
as programmers or coders, use a variety of programming languages and tools to create solutions for end-users
or businesses.

Types of Softwares:

● System software: System software is software that directly operates computer hardware and provides
basic functionality to users as well as other software for it to run smoothly. System software is a collection
of programs written to service other programs.

● Embedded software: resides in read-only memory and is used to control products and systems for
the consumer and industrial markets.

● Artificial intelligence software: Artificial intelligence (AI) software makes use of nonnumeric
algorithms to solve complex problems that are not amenable to computation or straightforward analysis
Engineering and scientific software: Engineering and scientific software have been characterized
● Legacy software: Legacy software are older programs that are developed decades ago. The quality of
legacy software is poor because it has inextensible design, convoluted code, poor and nonexistent
documentation, test cases and results that are not achieved.
As time passes legacy systems evolve due to following reasons:
-The software must be adapted to meet the needs of new computing environment or technology.
- The software must be enhanced to implement new business requirements.
- The software must be extended to make it interoperable with more modern systems.

● Application Software: Application software is a software that is designed for end-user to complete a
specific task. It is a product or program that is only intended to meet the needs of end users. It includes
word processors, spreadsheets, database management, inventory, and payroll software, among other
things.

● Programming Software: Programming software is a software that is designed for programmers to

develop program. It consist of code editor, compiler, interpreter, debugger etc.
Steps of Software Development
Software development is a well-structured process with several key stages.

1. Requirement Analysis:
The first step in software development is understanding the
requirements and based on that requirement gathering happen.
This stage involves identifying the needs, objectives, and constraints
of the project. The goal is to define what the software should do and
what problems it will solve.

2. Design:
● In the design phase, the software’s architecture and user
interface are developed. This step defines how the software
will work and how users will interact with it. Design includes
creating wireframes, prototypes, and system architecture
diagrams.
● After completing the architectural design phase, developers
move on to creating detailed designs for each component of
the system. This includes designing not only the user interface
but also encompassing databases and APIs. The intricate
decisions made in these detailed designs provide valuable
guidance throughout the coding phase.
3. Implementation
● The most important phase of the Software Development is the implementation phase, which comes after
the design phase. This phase will see the implementation of the design phase’s output.
● All of the planning done in the planning phase and the designing done in the designing phase are
implemented in this phase. Physical source code is created and deployed in the real world during this
phase.

4. Testing:
● Developers utilize unit tests to evaluate small code components, such as functions or methods. These te
sts play a crucial role in identifying and resolving bugs within isolated elements.
● Integration testing evaluates the smooth functioning of various software components. Its purpose is to
ensure seamless interactions between modules and efficient data transfer among them, resulting in a
robust system.
● In order to ensure that the software meets all the specified requirements, system testing evaluates it as a
whole. This comprehensive evaluation includes functional, performance, security, and other necessary
types of testing.
● User Acceptance Testing (UAT) occurs during the phase where end-users or clients validate the
software to ensure it meets their requirements. Identified issues or discrepancies are promptly addressed
before proceeding with deployment.
5. Deployment:
● Before deployment, the development team configures the target environment, whether it’s on-premises
servers, cloud-based infrastructure, or end-user devices. This may involve setting up servers, databases,
and configuring software dependencies.
● Developers carefully plan the process of deploying software, which includes aspects such as data
migration strategies, software installation procedures, and contingency measures for unexpected issues.
● The software is deployed to end-users or production environments. Ongoing monitoring is critical for
quickly identifying and addressing any issues that may arise following the deployment.

6. Maintenance and Updates:

● Once the software has been deployed, it is common for issues and bugs to arise. The dedicated team of
developers actively works on identifying, fixing, and thoroughly testing these problems. Regular updates
are provided to address any necessary improvements or changes that may arise
● Feature enhancements are made to the software as user needs evolve or new requirements arise.
Developers consistently implement new features and improvements in response to these changes.
● Regular security updates are crucial to address vulnerabilities and protect the software from cyber threats.

7. Documentation:
● The software developer provides user guides, manuals, and online help documentation to assist end-users
effectively navigate its features.
● Developers are responsible for creating technical documentation that outlines the architecture, code
structure, and APIs of a system. This documentation is crucial in helping future developers comprehend
and maintain the software.
Software Development Life Cycle (SDLC) or Application Development Life-Cycle:
● Software development life cycle (SDLC) is a structured process that is used to design, develop, and test
good-quality software. 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 life cycle 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 that meets users’ requirements.

Stages of the Software Development Life Cycle

The SDLC model involves six phases or stages while developing any software. SDLC is a collection of these six
stages, and the stages of SDLC are as follows:
Stage-1: Planning and Requirement Analysis:

● Planning is a crucial step in everything, just as in software development. In this same stage, requirement
analysis is also performed by the developers of the organization. This is attained from customer inputs,
and sales department/market surveys.
● The information from this analysis forms the building blocks of a basic project. The quality of the project
is a result of planning. Thus, in this stage, the basic project is designed with all the available information.

Stage-2: Defining Requirements

● In this stage, all the requirements for the target
software are specified. These requirements get
approval from customers, market analysts, and
stakeholders.
● This is fulfilled by utilizing SRS (Software
Requirement Specification). This is a sort of
document that specifies all those things that need to
be defined and created during the entire project
cycle.
Stage-3: Designing Architecture
● SRS is a reference for software designers to come up with the best architecture for the software. Hence,
with the requirements defined in SRS, multiple designs for the product architecture are present in the
Design Document Specification (DDS).
● This DDS is assessed by market analysts and stakeholders. After evaluating all the possible factors, the
most practical and logical design is chosen for development.
Stage-4: Developing Product
● At this stage, the fundamental development
of the product starts. For this, developers
use a specific programming code as per the
design in the DDS. Hence, it is important for
the coders to follow the protocols set by the
association. Conventional programming
tools like compilers, interpreters,
debuggers, etc. are also put into use at this
stage. Some popular languages like C/C++,
Python, Java, etc. are put into use as per
the software regulations.
Stage-5: Product Testing and Integration
● After the development of the product, testing of the software is necessary to ensure its smooth execution.
Although, minimal testing is conducted at every stage of SDLC. Therefore, at this stage, all the probable
flaws are tracked, fixed, and retested. This ensures that the product confronts the quality requirements of
SRS.
● Documentation, Training, and Support: Software documentation is an essential part of the software
development life cycle. A well-written document acts as a tool and means to information repository
necessary to know about software processes, functions, and maintenance. Documentation also provides
information about how to use the product. Training in an attempt to improve the current or future employee
performance by increasing an employee’s ability to work through learning, usually by changing his attitude
and developing his skills and understanding.

Stage-6: Deployment and Maintenance of Products

● After detailed testing, the conclusive product is released in phases as per the organization’s
strategy. Then it is tested in a real industrial environment. It is important to ensure its smooth
performance. If it performs well, the organization sends out the product as a whole. After retrieving
beneficial feedback, the company releases it as it is or with auxiliary improvements to make it
further helpful for the customers. However, this alone is not enough. Therefore, along with the
deployment, the product’s supervision.
Stage-6: Deployment and Maintenance of Products

What is the need for SDLC?

● SDLC is a method, approach, or process that is followed by a software development organization while
developing any software. SDLC models were introduced to follow a disciplined and systematic method
while designing software. With the software development life cycle, the process of software design is
divided into small parts, which makes the problem more understandable and easier to solve. SDLC
comprises a detailed description or step-by-step plan for designing, developing, testing, and maintaining
the software.
Software Development Life Cycle Models……

1. Waterfall Model: It is the fundamental model of the software development life cycle. This is a very simple
model. The waterfall model is not in practice anymore, but it is the basis for all other SDLC models. Because of
its simple structure, the waterfall model is easier to use and provides a tangible output. In the waterfall model,
once a phase seems to be completed, it cannot be changed, and due to this less flexible nature, the waterfall
model is not in practice anymore.

2. Agile Model: The agile model in SDLC was mainly designed to adapt to changing requests quickly. The main
goal of the Agile model is to facilitate quick project completion. The agile model refers to a group of development
processes. These processes have some similar characteristics but also possess certain subtle differences
among themselves.

3. Iterative Model: In the Iterative model in SDLC, each cycle results in a semi-developed but deployable
version; with each cycle, some requirements are added to the software, and the final cycle results in the
software with the complete requirement specification.

4. Spiral Model: The spiral model in SDLC is one of the most crucial SDLC models that provides support for
risk handling. It has various spirals in its diagrammatic representation; the number of spirals depends upon the
type of project. Each loop in the spiral structure indicates the Phases of the Spiral model.
5. V-Shaped Model: The V-shaped model in SDLC is executed in a sequential manner in V-shape. Each stage
or phase of this model is integrated with a testing phase. After every development phase, a testing phase is
associated with it, and the next phase will start once the previous phase is completed, i.e., development &
testing. It is also known as the verification or validation model.

6. Big Bang Model: The Big Bang model in SDLC is a term used to describe an informal and unstructured
approach to software development, where there is no specific planning, documentation, or well-defined phases.

Software Development Life Cycle (SDLC) models

1. Which of the following is not a life cycle model?

(A) Spiral model (B) Prototyping model (C) Waterfall model

(D) Capability maturity model
Solution: The correct Answer is (D).

2. What is the appropriate pairing of items in the two columns listing various activities encountered in a software
life cycle?
P. Requirements Capture 1. Module Development and Integration
Q. Design 2. Domain Analysis
R. Implementation 3. Structural and Behavioral Modeling
S. Maintenance 4. Performance Tuning

(A) P-3, Q-2, R-4, S-1

(B) P-2, Q-3, R-1, S-4
(C) P-3, Q-2, R-1, S-4
(D) P-2, Q-3, R-4, S-1
Solution: The correct Answer is (B).
Waterfall Model (Classic Life Cycle or Linear Sequential Model)

● The waterfall model demonstrates a linear sequential flow of the software

development process. This means that every stage of the development process starts
only when the preceding stage is complete. The stages do not overlap in this
waterfall model.
● Requirement analysis and specification: This phase aims at understanding the exact requirements of
the customer and documents them. Both the customer and the software developer work together so as
to document all the functions, performance and interfacing requirements of the software. It describes the
“what” of the system to be produced and not “how”. In this phase a large document called Software
Requirement Specification document (SRS) is produced which contains the detailed description of what
the system will do in the common language.
● Design phase: The aim of this phase is to transform the requirements gathered in the SRS into a
suitable form which permits further coding in a programming language. It defines the overall software
architecture together with high level and detailed design. All this work is documented as Software
Design Description document (SDD).
● Implementation and unit testing phase: The actual coding begins at his stage. The implementation
goes smoothly if the SDD has complete information required by the software engineers. During testing,
the code is thoroughly examined and modified. Small modules are testes in isolation initially. Thereafter,
these modules are tested by writing some overhead code in order to check the interaction between
these modules and the flow of intermediate output.
● Integration and system testing: This phase is highly crucial as the quality of the end product is
determined by the effectiveness of the testing carried out. Better output will lead to satisfied customers,
lower maintenance costs and accurate results. Unit testing determines the efficiency of individual
modules. However, in this phase the modules are tested for their interactions with each other and with
the system.
● Operation and maintenance phase: Maintenance is the task performed by every user once the software
has been delivered to the customer, installed and operational. Thus, the delivery of software initiates the
maintenance phase. The time and efforts spent on the software to keep it operational after release is
important. It includes activities like error correction, removal of obsolete functions, optimization and
enhancements of functions. It may span for 5 to 50 years.
Waterfall model Advantages:
• Disciplined approach
• Careful checking by the Software Quality Assurance Group at the end of each phase.
• Testing in each phase.
• Documentation available at the end of each phase.

Waterfall model problems:

• It is difficult to respond to changing customer requirements.
• Therefore, this model is only appropriate when the requirements are well-understood and changes will be fai
limited during the design process.
• Few business systems have stable requirements.
• The waterfall model is mostly used for large systems engineering projects where a system is developed at
several sites.
• The customer must have patience. A working version of the program will not be available until late in the
project time-span
• Feedback from one phase to another might be too late and hence expensive.
● Poor model for long and ongoing projects.
V-Model (Verification and Validation model)
● It is based on the association of a testing phase for each
corresponding development stage. The development of each
step is directly associated with the testing phase. The next
phase starts only after completion of the previous phase i.e.,
for each development activity, there is a testing activity
corresponding to it.
Phases in a V-Model
● Requirements Gathering and Analysis: The first phase of the
V-Model is the requirements gathering and analysis phase,
where the customer’s requirements for the software are gathered
and analyzed to determine the scope of the project.
● Design: In the design phase, the software architecture and
design are developed, including the high-level design and
detailed design.
● Implementation: In the implementation phase, the software is
built based on the design.
● Testing: In the testing phase, the software is tested to ensure that it meets the customer’s requirements and
is of high quality.
● Deployment: In the deployment phase, the software is deployed and put into use.
● Maintenance: In the maintenance phase, the software is maintained to ensure that it continues to meet the
customer’s needs and expectations.
Advantages of V-Model: -This is a highly disciplined model and Phases are completed one at a time.
-V-Model is used for small projects where project requirements are clear.
-Simple and easy to understand and use.
-This model focuses on verification and validation activities early in the life cycle thereby enhancing the
probability of building an error-free and good quality product.
-It enables project management to track progress accurately.
-Clear and Structured Process: The V-Model provides a clear and structured process for software development,
making it easier to understand and follow.
-Emphasis on Testing: The V-Model places a strong emphasis on testing, which helps to ensure the quality and
reliability of the software.
-Improved Traceability: The V-Model provides a clear link between the requirements and the final product,
making it easier to trace and manage changes to the software.
-Better Communication: The clear structure of the V-Model helps to improve communication between the
customer and the development team.
Disadvantages of V-Model: - High risk and uncertainty.
-It is not good for complex and object-oriented projects.
-It is not suitable for projects where requirements are not clear and contain a high risk of changing.
-This model does not support iteration of phases.
-It does not easily handle concurrent events.
-Inflexibility: The V-Model is a linear and sequential model, which can make it difficult to adapt to changing
requirements or unexpected events.
-Time-Consuming: The V-Model can be time-consuming, as it requires a lot of documentation and testing.
-Overreliance on Documentation: The V-Model places a strong emphasis on documentation, which can lead to
an overreliance on documentation at the expense of actual development work.
Iterative Enhancement Model ( Incremental model )
● Iterative development is a software development method that divides the development process into smaller
pieces of a major program. Each element, known as the "iteration," reflects the whole process and
comprises phases for planning, design, development and testing.
● Encourages a software product’s ongoing evolution
and improvement.

● creates an environment where development teams can more effectively adjust to changing requirements
by segmenting the software development process into smaller, more manageable parts.
● Every iteration improves on the one before it, adding new features and fixing problems found in earlier
stages. Members of the team, stakeholders and end users are encouraged to collaborate and
communicate continuously to make sure the software meets changing needs and expectations. Until the
software is finished being built, the iteration process is carried out, which involves giving the user the
increments.
Iterative Model Advantage:
●Early and fast in the life cycle, certain working functions can be created.
●Early and periodic results are achieved.
●One can plan development parallelly.
●Growth in development may be assessed.
●It is less expensive to modify the scope/needs.
●Smaller iterations make it simpler to test and troubleshoot.
●Risks are recognized and resolved and each iteration is a milestone easily controlled.
●Risk management is easier.
●The operating product is supplied with each increase.

Iterative Model Disadvantages:

●It is not appropriate for minor tasks.
●It may require additional resources.
●Due to imprecise criteria, design might be altered over and over again.
●Changes in budget requirements may cause.
●The completion date of the project was not certain as the specifications had changed.
●Higher cost
●Due to constant changes, there may be delays in documentation, making it more difficult
to maintain comprehensive documentation.
●Continuous customer engagement may not be possible in all scenarios, which impacts the effectiveness
of the model.
Prototyping Model
● Prototyping is defined as the process of developing a working
replication of a product or system that has to be engineered. It
offers a small-scale facsimile of the end product and is used for
obtaining customer feedback
● This model is used when the customers do
not know the exact project requirements
beforehand. In this model, a prototype of
the end product is first developed, tested,
and refined as per customer feedback
repeatedly till a final acceptable prototype
is achieved which forms the basis for
developing the final product.

● The prototype may be a usable program but is not suitable as the final software product.

● The code for the prototype is thrown away. However experience gathered helps in developing the actual
system.
● The development of a prototype might involve extra cost, but overall cost might turnout to be lower
than that of an equivalent system developed using the waterfall model.
 Step 1: Requirement Gathering and Analysis: This is the initial step in
designing a prototype model. In this phase, users are asked about what they
expect or what they want from the system.
Step 2: Quick Design: This is the second step in the Prototyping Model. This
model covers the basic design of the requirement through which a quick
overview can be easily described.
Step 3: Build a Prototype: This step helps in building an actual prototype
from the knowledge gained from prototype design.
Step 4: Initial User Evaluation: This step describes the preliminary testing
where the investigation of the performance model occurs, as the customer
will tell the strengths and weaknesses of the design, which was sent to the
developer.
Step 5: Refining Prototype: If any feedback is given by the user, then
improving the client’s response to feedback and suggestions, the final
system is approved.
Step 6: Implement Product and Maintain: This is the final step in the phase of
the Prototyping Model where the final system is tested and distributed to
production, here the program is run regularly to prevent failures.

Types of Prototyping Models:There are four types of Prototyping Models, which are described below.
1. Rapid Throwaway Prototyping 2. Evolutionary Prototyping 3. Incremental Prototyping
4. Extreme Prototyping
Advantages of Prototyping Model:
● Prototyping can be used to test and validate design decisions, allowing for adjustments to be made
before significant resources are invested in development.
● Prototyping can help reduce the risk of project failure by identifying potential issues and addressing
them early in the process.
● Prototyping can facilitate communication and collaboration among team members and stakeholders,
improving overall project efficiency and effectiveness.
● Prototyping can help bridge the gap between technical and non-technical stakeholders by providing a
tangible representation of the product.
Disadvantages:

● The prototype may give a false sense of completion, leading to the premature release of the product.
● The prototype may not consider technical feasibility and scalability issues that can arise during the final
product development.
● The prototype may be developed using different tools and technologies, leading to additional training and
maintenance costs.
● The prototype may not reflect the actual business requirements of the customer, leading to dissatisfaction
with the final product
Spiral Model ( Meta Model ):
● The spiral development model is a risk-driven process model generator that is used to guide
multi-stakeholder concurrent engineering of software intensive systems. It has two main distinguishing
features. One is a cyclic approach for incrementally growing a system’s degree of definition and
implementation while decreasing its degree of risk. The other is a set of anchor point milestones for ensuring
stakeholder commitment to feasible and mutually satisfactory system solutions.

A single loop spiral actually represents

the Iterative Waterfall Model.
The functions of these four quadrants are discussed below:
● Objectives determination and identify alternative solutions: Requirements are gathered from the
customers and the objectives are identified, elaborated, and analyzed at the start of every phase. Then
alternative solutions possible for the phase are proposed in this quadrant.
● Identify and resolve Risks: During the second quadrant, all the possible solutions are evaluated to
select the best possible solution. Then the risks associated with that solution are identified and the risks
are resolved using the best possible strategy. At the end of this quadrant, the Prototype is built for the best
possible solution.
● Develop the next version of the Product: During the third quadrant, the identified features are
developed and verified through testing. At the end of the third quadrant, the next version of the software is
available.
● Review and plan for the next Phase: In the fourth quadrant, the Customers evaluate the so-far
developed version of the software. In the end, planning for the next phase is started.
Phases of the Spiral Model:
Planning: The first phase of the Spiral Model is the planning phase, where the scope of the project is determined
and a plan is created for the next iteration of the spiral.
Risk Analysis: In the risk analysis phase, the risks associated with the project are identified and evaluated.
Engineering: In the engineering phase, the software is developed based on the requirements gathered in the
previous iteration.
Evaluation: In the evaluation phase, the software is evaluated to determine if it meets the customer’s
requirements and if it is of high quality.
Planning: The next iteration of the spiral begins with a new planning phase, based on the results of the
evaluation.
Advantages of the Spiral Model
- Changing requirements can be accommodated.
- Allows extensive use of prototypes.
- Requirements can be captured more accurately.
- Users see the system early.
- Development can be divided into smaller parts and the risky parts can be developed earlier which helps
in better risk management.
- risk analysis and risk handling at every phase, Good for large projects, Flexibility in Requirements,
Customer Satisfaction, Iterative and Incremental Approach, Emphasis on Risk Management, Improved
Communication, Improved Quality

Disadvantages:
- Management is more complex.
- End of the project may not be known early.
- Not suitable for small or low risk projects and could be expensive for small projects.
- Process is complex
- Spiral may go on indefinitely.
- Large number of intermediate stages requires excessive documentation.
- Complex, Expensive, Too much dependability on Risk Analysis, Difficulty in time management,
Time-Consuming, Resource Intensive
Rapid application development model (RAD)
● The RAD Model was first proposed by IBM in the 1980s. The RAD model is a type of incremental
process model in which there is an extremely short development cycle. When the requirements are fully
understood and the component-based construction approach is adopted then the RAD model is used.
● Development takes place in a series of short cycles or iterations. At any time, the development team
focuses on the present iteration only, and therefore plans are made for one increment at a time. The time
planned for each iteration is called a time box. Each iteration is planned to enhance the implemented
functionality of the application by only a small amount. During each time box, a quick-and-dirty
prototype-style software for some functionality is developed. The customer evaluates the prototype and
gives feedback on the specific improvements that may be necessary. The prototype is refined based on
the customer feedback.

RAD model has the following phases:

● Business Modeling: The information flow among business functions
is defined by answering questions like what information drives the business
process, what information is generated, who generates it, where does the
information go, who process it and so on.
● Data Modeling: The information collected from business modeling is refined
into a set of data objects (entities) that are needed to support the business.
The attributes (character of each entity) are identified and the relation
between these data objects (entities) is defined.
● Process Modeling: The data object defined in the data modeling phase are transformed to achieve the
information flow necessary to implement a business function. Processing descriptions are created for
adding, modifying, deleting or retrieving a data object.
● Application Generation: Automated tools are used to facilitate construction of the software; even they
use the 4th GL techniques.
● Testing and Turn over: Many of the programming components have already been tested since RAD
emphasis reuse. This reduces overall testing time. But new components must be tested and all interfaces
must be fully exercised.
Advantages of the RAD Model:
- Changing requirements can be accommodated.
- Progress can be measured.
- Iteration time can be short with use of powerful RAD tools.
- Productivity with fewer people in a short time.
- Reduced development time.
- Increases reusability of components.
- Quick initial reviews occur.
- Encourages customer feedback.
- Integration from very beginning solves a lot of integration issues.

Disadvantages:
- Dependency on technically strong team members for identifying business requirements.
- Only system that can be modularized can be built using RAD.
- Requires highly skilled developers/designers.
- High dependency on Modelling skills.
- Inapplicable to cheaper projects as cost of Modelling and automated code generation is very high.
- Management complexity is more.
- Suitable for systems that are component based and scalable.
- Requires user involvement throughout the life cycle.
- Suitable for project requiring shorter development times.
Agile Software Development
● A software development methodology that values flexibility, collaboration, and customer satisfaction. It is
based on the Agile Manifesto, a set of principles for software development that prioritize individuals and
interactions, working software, customer collaboration, and responding to change.

● An iterative and incremental approach to software development that emphasizes the importance of
delivering a working product quickly and frequently. It involves close collaboration between the
development team and the customer to ensure that the product meets their needs and expectations.

12 Principles

4 Core Values

● Combination of iterative and incremental process models with focus on process adaptability and customer
satisfaction by rapid delivery of working software product. Agile Methods break the product into small
incremental builds. These builds are provided in iterations. Each iteration typically lasts from about one to
three weeks.
● The most popular Agile methods include
Rational Unified Process (1994), Scrum (1995),
Crystal Clear, Extreme Programming (1996),
Adaptive Software Development, Feature
Driven Development, and Dynamic Systems
Development Method (DSDM) (1995). These
are now collectively referred to as Agile
Methodologies, after the Agile Manifesto was
published in 2001.
● Agile model believes that every project needs
to be handled differently and the existing
methods need to be tailored to best suit the
project requirements. In Agile, the tasks are
divided to time boxes (small time frames) to
deliver specific features for a release.
● Iterative approach is taken and working software build is delivered after each iteration. Each build is
incremental in terms of features; the final build holds all the features required by the customer.

● Agile is a framework that defines how software development needs to be carried on. Agile is not a single
method, it represents the various collection of methods and practices that follow the value statements
provided in the manifesto. Agile methods and practices do not promise to solve every problem present in the
software industry (No Software model ever can). But they sure help to establish a culture and environment
where solutions emerge.
Agile Software development cycle:

Step 1: In the first step, concept, and business opportunities in each possible project are identified and the
amount of time and work needed to complete the project is estimated. Based on their technical and financial
viability, projects can then be prioritized and determined which ones are worthwhile pursuing.

Step 2: In the second phase, known as inception, the customer is consulted regarding the initial requirements,
team members are selected, and funding is secured. Additionally, a schedule outlining each team’s
responsibilities and the precise time at which each sprint’s work is expected to be finished should be developed.

Step 3: Teams begin building functional software in the third step, iteration/construction, based on requirements
and ongoing feedback. Iterations, also known as single development cycles, are the foundation of the Agile
software development cycle.

1.Concept 2. Inception 3. Iteration/construction 4. Release

5. Production 6. Retirement
Agile Manifesto principles:

Individuals and interactions− In Agile development, self-organization and motivation are important, as are
interactions like co-location and pair programming.
Working software− Demo working software is considered the best means of communication with the customers
to understand their requirements, instead of just depending on documentation.
Customer collaboration− As the requirements cannot be gathered completely in the beginning of the project
due to various factors, continuous customer interaction is very important to get proper product requirements.
Responding to change− Agile Development is focused on quick responses to change and continuous
development.
Advantages of the Agile Model
-Is a very realistic approach to software development.
-Promotes teamwork and cross training.
-Functionality can be developed rapidly and demonstrated.
-Resource requirements are minimum.
-Suitable for fixed or changing requirements.
-Delivers early partial working solutions.
-Good model for environments that change steadily.
-Minimal rules, documentation easily employed.
-Enables concurrent development and delivery within an overall planned context.
-Little or no planning required.
-Easy to manage.
- Gives flexibility to developers.
Disadvantages
-Not suitable for handling complex dependencies.
-More risk of sustainability, maintainability and extensibility.
-An overall plan, an agile leader and agile PM practice is a must without which it will not work.
-Strict delivery management dictates the scope, functionality to be delivered, and adjustments to meet the
deadlines.
-Depends heavily on customer interaction, so if customer is not clear, team can be driven in the wrong direction.
-There is a very high individual dependency, since there is minimum documentation generated.
-Transfer of technology to new team members may be quite challenging due to lack of documentation.
VERIFICATION AND VALIDATION ( (V&V)
● Process of investigating that a software system satisfies specifications and standards and it fulfills the
required purpose.

● Verification is the process of checking that a software achieves its goal without any bugs. It is the
process to ensure whether the product that is developed is right or not. It verifies whether the developed
product fulfills the requirements that we have. Verification is Static Testing.
● Activities involved in verification: Inspections, Reviews, Walkthroughs, Desk-checking

● Validation is the process of checking whether the software product is up to the mark. In other words, the
product has high level requirements. It is the process of checking the validation of product i.e., it checks
what we are developing is the right product. It is validation of actual and expected products. Validation is
the Dynamic Testing.
Dynamic Testing: Validation Testing is known as Dynamic Testing in which we examine whether we have
developed the product right or not and also about the business needs of the client. Here are some of the
activities that are involved in Validation. Black Box Testing, White Box Testing, Unit Testing,
Integration Testing
V&V Techniques:
Software Requirement Specification (SRS)
● A document that captures complete description about how the system is expected to perform. It is usually
signed off at the end of requirements engineering phase.
● Software Requirement Specification is termed as SRS document. This document serves as a detailed
illustration of functional and non-functional requirements needed that software should fulfill.
Features of SRS :
● This document bridges gap between user and developer.
● Documents board imaginations into a structural layout.
● Used for measuring initial costs and efforts.
● Works as an agreement between communicating parties. Example : Consider a software to monitor
employee performance. This will require basic modules such as Login Module, Administrator Module,
Employee Module, and Reporting Module. SRS document helps to manage these modules.
Qualities of SRS:
Correct, Unambiguous, Complete, Consistent, Ranked for
importance and/or stability, Verifiable, Modifiable, Traceable
● After we have removed all
inconsistency, anomalies,
incompleteness from the
document, we go about documenting
the requirements. Now, let see how to
write the SRS document.
Introduction:
Purpose of this Document – At first, main aim of why this document is necessary and what’s purpose of
document is explained and described.
Scope of this document – In this, overall working and main objective of document and what value it will provide
to customer is described and explained. It also includes a description of development cost and time required.
Overview – In this, description of product is explained. It’s simply summary or overall review of product.

General description:
In this, general functions of product which includes objective of user, a user characteristic, features, benefits,
about why its importance is mentioned. It also describes features of user community.

Functional Requirements:
In this, possible outcome of software system which includes effects due to operation of program is fully
explained. All functional requirements which may include calculations, data processing, etc. are placed in a
ranked order. Functional requirements specify the expected behavior of the system-which outputs should be
produced from the given inputs. They describe the relationship between the input and output of the system. For
each functional requirement, detailed description all the data inputs and their source, the units of measure, and
the range of valid inputs must be specified.

Interface Requirements:
In this, software interfaces which mean how software program communicates with each other or users either in
form of any language, code, or message are fully described and explained. Examples can be shared memory,
data streams, etc.
Performance Requirements:
In this, how a software system performs desired functions under specific condition is explained. It also explains
required time, required memory, maximum error rate, etc. The performance requirements part of an SRS
specifies the performance constraints on the software system. All the requirements relating to the performance
characteristics of the system must be clearly specified. There are two types of performance requirements: static
and dynamic. Static requirements are those that do not impose constraint on the execution characteristics of the
system. Dynamic requirements specify constraints on the execution behaviour of the system.

Design Constraints:
In this, constraints which simply means limitation or restriction are specified and explained for design team.
Examples may include use of a particular algorithm, hardware and software limitations, etc. There are a number
of factors in the client’s environment that may restrict the choices of a designer leading to design constraints
such factors include standards that must be followed resource limits, operating environment, reliability and
security requirements and policies that may have an impact on the design of the system. An SRS should identify
and specify all such constraints.

Non-Functional Attributes:
In this, non-functional attributes are explained that are required by software system for better performance. An
example may include Security, Portability, Reliability, Reusability, Application compatibility, Data integrity,
Scalability capacity, etc.
Preliminary Schedule and Budget:
In this, initial version and budget of project plan are explained which include overall time duration required and
overall cost required for development of project.
Appendices:
In this, additional information like references from where information is gathered, definitions of some specific
terms, acronyms, abbreviations, etc. are given and explained.