1

OBJECT – ORIENTED SOFTWARE ENGINEERING

UNIT I

Software Engineering : Software Engineering process paradigms, Process

Models – Waterfall Model, Iterative Model, RAD Model, Prototype Model,
Requirement Analysis, Analysis Model.

Software
Definition : The software (also abbreviated as an SW or S/W) is a collection of data, programs,
procedures, instructions, and documentation that perform various predefined tasks on a computer system or
other electronic device. It enables users to interact with the computer.
It is a non-tangible component of a computer system that enables the hardware to function and perform
various operations. It is a collection of code that is designed to perform a specific task or set of tasks or
operations.
Use of software is increasingly becoming common in our day-to-day life. Most software deal with input of
multiple data types, process it by pre-defined rules, validate the results and produce an output for some
purpose. All software have a goal to achieve.
Software could be intended for
✓ Data processing,
✓ Information processing and sharing,
✓ Communication and control,
✓ Computing and decision making,
✓ Controlling the process based on certain rules and so on.

Types of software :
Software can be categorized into two types : System Software and Application Software.

System software : System software is a type of computer program that is designed to run a computer's
hardware and application programs. A computer system without system software cannot function.
Ex : Operating Systems, Device Drivers, and utility programs that help manage and maintain the system.

The Application software refers to programs that are designed to perform specific tasks for users.
Ex : Word processors, spreadsheets, email clients, web browsers, and video editing software etc.,

Software development is a creative and iterative process that involves developing software from scratch,
adapting existing software, or customizing software to meet specific requirements. It requires a range of
technical skills, including programming languages, software design patterns, and software development
methodologies.
Software can be developed in a variety of programming languages, such as C, C++, Java, Python etc.,

Software can be created using programming languages and tools that enable developers to write and compile
code that can be executed by a computer. Software can also be downloaded or installed from the internet, or
purchased as a physical product such as a CD or USB drive.

Software can be developed by individuals, companies, or open-source communities, and can be distributed
through various channels, such as retail stores, online marketplaces, or direct downloads from the
developer's website. Software can be installed on a local computer or accessed through a web-based
interface.

Components of software : Software is a collection of programs. Any program is a subset of software. The
set of programs become software only if documentation and operating procedure manuals are prepared.
 2

Software also includes a set of documents such as the software manuals, meant for users to understand the
software system. Modern software comprises the Source code, Executables, Design Documents,
Operations and System Manuals and Installation Manuals and Implementation Manuals.

• Software is developed or engineered, it is not manufactured in the classical sense:

Software is both developed and engineered.
✓ Software development refers to the process of creating software, including designing, coding,
testing, and debugging.
✓ Software engineering refers to the application of engineering principles and best practices to the
development of software.
✓ Software development is a creative and iterative process that involves developing software from
scratch, adapting existing software, or customizing software to meet specific requirements.
✓ It requires a range of technical skills, including programming languages, software design
patterns, and software development methodologies.
✓ This includes managing software projects, ensuring software quality, and using software
development best practices to deliver software that is reliable, maintainable, and scalable.
✓ Software development and engineering are both essential components of creating high-quality
software that meets the needs of users and stakeholders.
• Software does not “wear out” :
Hardware can wear out over time due to physical use and environmental factors. Components such as
hard drives, fans, power supplies and batteries can degrade and eventually fail after extended use.
Mechanical components such as switches and buttons can also wear out due to repetitive use.
Factors such as temperature, humidity, and dust can also affect the lifespan of hardware components.
But Software does not wear out. Software can become outdated. As technology advances, newer and
more efficient programming languages and development tools become available, and older software may
not be able to keep up with the latest developments. To keep software running smoothly and securely, it
is important to maintain it regularly and update it as needed. This may involve fixing bugs, patching
security vulnerabilities and optimizing performance. It may be necessary to upgrade to newer versions of
the software or switch to different software entirely.

Good software :
✓ Software can have number of attributes, which together will decide whether it is good or bad.
✓ The four essential attributes of good software are :
o maintainability, dependability,
o efficiency and usability.
✓ The definition of good software changes with the person who evaluates it. Each one will evaluate the
different attributes differently in order to decide whether the software is good or bad.
✓ The software is required by the customer, used by various end users in the organization and
developed by the software engineer.
 3

✓ Good software is software that meets the needs and requirements of its users, reliable, efficient, and easy
to use.

Good software should be secure with built-in protections against threats like hacking and malware,
and it should be compatible with the hardware and software environments. Good software should also be
well-maintained, with regular updates and bug fixes to ensure it continues to function properly over
time.

In addition, good software should be cost-effective. It should be adaptable and must be able to evolve and
meet changing needs over time. Finally, good software should be supported by a helpful and
responsive customer service team that can provide assistance and answer questions as needed.

Software Application Domains :

Software applications can be designed in many application areas such as business, education, hospitals,
factories etc., Here are some of the most common software application domains:

1. Business Applications: Software designed to process business applications is called business

software. It refers to software applications that are designed to help businesses and organizations
perform specific tasks or functions such as accounting, finance, customer relationship management
(CRM), human resources management and enterprise resource planning (ERP) systems. Software
written for Payroll, Accounting, Inventory, Planning and Scheduling of activities in the corporate world
are examples of business software.

2. Education Applications: These applications are designed for educational purposes, such as online
learning platforms, virtual classrooms, and Student Information Systems, Student Admission Systems,
student Attendance Management System etc.,

3. Embedded software : Software, when written to perform certain functions under control conditions
and further embedded into hardware as a part of larger systems is called embedded software. It
resides in Read-Only-Memory (ROM) and is used to control the various functions of the products such
as smartphones, smart TVs, washing machines, microwave oven etc.,

4. Design/ Engineering /Scientific software : Design, engineering or scientific softwares deal with
processing requirements in their specific fields. They are used for analysis of engineering data, statistical
data for interpretation and decision-making. CAD (Computer-Aided Design), CAM (Computer-Aided
Manufacturing), CAE (Computer-Aided Engineering) are examples of such software.

5. Healthcare Applications: These applications are designed for healthcare providers and patients, such
as electronic health records (EHRs), telemedicine, and medical billing software.

6. E-commerce Applications: These applications are designed for online shopping, such as shopping
carts, payment gateways, and inventory management systems.

7. Artificial Intelligence (AI) software : It uses non-numerical algorithms, which use the data and
information generated in the system, to solve the complex problems. Expert Systems, Knowledge-based
Systems, image and voice recognition systems, artificial neural networks are examples of AI software.

8. Social Networking Applications: These applications are designed for social interactions, such as
messaging apps, social media platforms, and online communities.

9. Mobile Applications: These applications are designed for mobile devices, such as smart-phones and
tablets, etc.,

10. Gaming Applications: These applications are designed for gaming and can be played on different
platforms such as consoles, computers, and mobile devices.
 4

Software Process
Definition :
The Software process refers to the set of activities, methods and techniques that are used to develop,
maintain and improve software. It involves a series of steps that software developers and project teams
follow to design, build, test and deploy software applications. The software process includes a range of
activities to build quality software that satisfies the requirements of stakeholders of the organization.

Framework :
In software engineering, a framework is a
collection of pre-written code, tools, and
libraries that provide a structure and set of
guidelines for building software
applications. Frameworks are designed to be
flexible and customizable allowing developers
to build on top of them to create applications
that meet specific requirements.

Some popular frameworks in software

engineering include Ruby on Rails, Django,
Angular, React, Laravel, Spring, and .NET.

Activity :
In software engineering, an activity refers to a
specific task or set of tasks that are performed
to achieve a particular goal in the software
development process. The activities may
include requirements gathering, design, coding,
testing, deployment, and maintenance.
Each activity typically has
o a set of inputs, such as requirements
or design specifications, and
o produces a set of outputs, such as
code or documentation.
Types of activities :
• Generic activities of software process
• Umbrella activities of software process

A software process typically

• involves several stages, which can be
sequential or iterative in nature,
depending on the methodology being
used. For instance, a popular software development methodology is the Agile methodology, which
uses iterative and incremental development cycles.
• Software process helps project teams to manage
o the complexity of software development,
o identify potential problems,
o ensures end product is delivered with high quality.
• The selection of the software development methodology by the organization depends
o size and complexity of the project, and
o team’s experience and skills.
Frameworks are used
o to speed up the development process,
o improve the quality of code and
o to reduce the probability of errors and bugs,
o for developing large-scale web applications, mobile apps and desktop software.
 5

A framework typically includes

o set of abstract classes and interfaces that define the basic functionality of an application, as well as
o set of rules and conventions for organizing and structuring code.

Generic Framework Activities in Software Engineering :

The software process is a set of activities that are performed to develop high-quality software. The generic
framework activities of the software process are:

1. Communication : Communication is the process of exchanging information between various

stakeholders involved in the software development process. It includes identifying stakeholders, defining
their communication needs, establishing communication channels and coordinating activities among
team members.
2. Planning : This activity involves defining the project's scope, developing a project plan, identifying and
allocating resources, and creating a timeline for the project's activities.
3. Modeling : Modeling involves creating different models to capture various aspects of the software
product such as requirements models, design models, data models, structural and behavioral models.
These models help to visualize the software product and ensure that it meets the stakeholders'
requirements.

4. Construction : This activity involves the actual development of the software product using various
programming languages (Java, C, C++, Visual Basic, jQuery, PHP etc.,) and tools, testing the software
product, documenting and integrating the software product.

5. Deployment : Deployment involves preparing the software product for release, including installation,
configuration, and testing in a production environment. It also involves delivering the software product
to the end-users.

6. Maintenance : Maintenance involves modifying the software product to correct defects, improve
performance, or adapt to changing requirements. It also ensure that software should continue to
compatible with new hardware and software environments.

These activities are not performed in a strict sequence, and some activities may overlap or occur
concurrently. The software process is iterative and feedback-driven, meaning that the activities are repeated
until the desired outcome is achieved. Effective management and coordination of these activities are
essential for delivering high-quality software products that meet the stakeholders' requirements.

Umbrella activities in software engineering :

Umbrella activities, also known as cross-functional activities, are activities that are not specific to any
particular phase of the software development process, but span across multiple phases. These activities
provide a framework and support for the overall software development process.
1. Requirements Gathering : This involves gathering and analyzing the software requirements from the
customer or end-user and defining the scope of the software. It also refers to specifying, validating, and
managing the requirements for a software system.
2. Project management : Project management activities involve planning, organizing, and managing
resources to achieve specific project goals. It includes tasks such as communication, project planning,
scheduling, project tracking, risk management etc.,
3. Software design : This involves designing the software architecture and detailed design specifications
for the software system that meets the user requirements.
4. Software construction : This involves actual coding and development of the software.

5. Quality assurance : Quality assurance activities are aimed at ensuring that the software meets the
desired quality standards and is free from defects. It also includes tasks such as software testing, code
reviews and quality audits.
 6

6. Software testing : This activity involves verifying that the software product meets the specified
requirements and identifying and fixing any defects or errors. This involves verifying and validating the
software system to ensure that it meets the specified requirements.

7. Documentation : Documentation activities involve creating and maintaining documentation related to

the software development process. It includes tasks such as requirements documentation, design
documentation, technical specifications and user manuals.

8. Deployment : Deployment activities involve deploying the software to the production environment. It
includes tasks such as installation, configuration, and migration of the software.

9. Configuration management : Configuration management activities are aimed at managing the

changes made to the software during its development lifecycle. It includes tasks such as version control,
change control, and release management.

10. Training : Training activities involve providing training to the developers, users, and other stakeholders
involved in the software development process. It includes tasks such as conducting training sessions,
creating training materials, and providing support to users.

11. Software maintenance : These activities are aimed at managing the changes made to the software
during its development life cycle. They are aimed at modifying and enhancing the software system after
it has been released to fix bugs, add new features, or improve performance. It also includes tasks such as
version control, change control and release management.

These umbrella activities play a crucial role in ensuring the success of the software development process.
They help to ensure that the software is developed efficiently, meets the desired quality standards, and is
delivered on time and within budget.

Software Engineering
Definition :
• According to IEEE, software Engineering is defined as “The application of a systematic, disciplined,
quantifiable approach to the development, operation and maintenance of software”.
• Software engineering can be defined as a systematic approach to develop software within specified time
and budget.
• Software Engineering is an engineering branch associated with the development of software product
using well-defined scientific principles, methods and procedures. The outcome of software engineering
is an efficient and reliable software product.

Definition : Software Engineering is the application of engineering principles, methods and techniques to
the design, development, testing and maintenance of software systems.

SE - Operational Activities :
Software engineering involves a range of activities
o Requirement analysis and definition
o Software scope and determining its boundaries
o Planning, scheduling, executing, monitoring and control of software development
o Testing at all phases for quality assurance as required by the customer
o Documenting the software for its stakeholders
o Implementation through demonstration, installation and execution at customer’s site

Software product will be more effective when the software engineer has
✓ Domain Knowledge of the Software System
✓ Project Management Skills
✓ Higher level Communication skills and leadership qualities
✓ Essential Technology and language skills
 7

Software Product : A program is an executable code, which performs a particular task. Software is
considered to be collection of executable programming code, associated libraries and documentations.
Software designed for a specific requirement is called Software Product.
Ex : Telecommunication, Military, Medical sciences, Online shopping, Online Banking, etc.,
The software is the key element in all computer based systems and products. The main objective of
software engineering is to give a framework for building software product with best quality.

Software Engineering - Layered Technology : Software Engineering is a fully layered technology. The
main objective of software engineering layers is to help software developers obtain high-quality software.
There are four types of layers in Software Engineering. To develop software, we need to go from one layer
to another. All these layers are related to each other. It is the application of principles that deals with the
design, development, testing, deployment and management of systems.

1. Quality Focus : It includes the characteristics of good quality software such as

o Maintainability of the software.
o Providing integrity
o Checking the correctness of the functions (test input and test output) by the software.
o Providing security so that the unauthorized user cannot access information or data.
o Usability of the software.
2. Process : It is the base layer or foundation layer for the software engineering. It covers all activities,
actions and tasks required to be carried out for software development. It defines a framework that
includes different activities and tasks.
3. Methods : Methods encompass a broad array of tasks that include communication, requirements
analysis, design modelling, program construction, testing and support.
4. Tools : Software Engineering tools provide automated or semi-automated support for the process and
methods. When tools are integrated, information created by one tool can be used by another tool, a
system for the support of software development is called Computer-Aided Software Engineering. CASE
tools are used by software project managers, analysts and engineers to develop software system.
i. Documentation tools : Documentation in a software project starts prior to the software process,
goes throughout all phases of SDLC and after the completion of the project. They generate
documents for technical users and end users. Technical users are mostly in-house professional of the
development team who refer to system manual, reference manual, training manual, installation
manuals etc.,

ii. Project management tools : These tools are used for project planning, cost and effort estimation,
project scheduling and resource planning. Project management tools help in storing and sharing
project information in real-time throughout the organization.

iii. Process modelling tools : They help the managers to choose a process model or modify it as per
the requirement of software product.

iv. Diagram tools : These tools are used to represent the system structure in a graphical form. They are
also used to represent system components, data and control flow among various software
components.
 8

Software Engineering Process Paradigms

A Software Engineering Process paradigm is a set of

principles, concepts and practices that guide software
development. Software is considered to be a collection of
executable programming code, associated libraries and
documentation.
The Programming paradigm is a subset of Software Design
paradigm which is further a subset of Software Development
paradigm.

Objectives : The objectives of software paradigms are to help

developers create better software more efficiently, while also
making it easier to maintain and update over time.

1. Improving software quality : Many software paradigms focus on improving the quality of software
by reducing bugs, improving performance, and increasing reliability.

2. Improving collaboration : Many software paradigms promote collaboration between developers by

providing tools and frameworks that facilitate teamwork and communication.

3. Enhancing productivity : Some software paradigms are designed to help developers work more
efficiently by providing tools and frameworks that simplify the development process.

4. Promoting code reuse : Many software paradigms encourage developers to write reusable code that
can be used across different projects and applications.

Programming Paradigm : The programming paradigms are a way to classify programming

languages.
The computer programming languages can be classified into following major Programming paradigms :

Procedural (or Structural ) programming paradigm : Procedural Programming can be defined as a

programming model based upon the concept of calling procedure. Procedures also known as routines,
subroutines or functions, simply consist of a series of computational steps to be carried out.
Examples : FORTRAN, ALGOL, COBOL, BASIC, Pascal and C.
✓ Large programs are divided into smaller programs known as functions.
✓ Employs top-down approach in program design.
✓ Emphasis is on development of functions rather than data.

Object-Oriented Programming : It is a programming model which is based upon the concept of

objects. Objects contain data in the form of attributes and code in the form of methods. Computer
programs are designed using the concept of objects that interact with the real world. It includes several
powerful concepts such as data abstraction, data encapsulation, inheritance, polymorphism, dynamic
binding and message passing.
Examples : C++, Java, Visual Basic, Simula 67, Ada, PHP, JavaScript etc.,
 9

✓ The programming problems are decomposed into a number of entities called objects. They built data
and functions around these entities.
✓ Follows bottom-up approach in program design.
✓ Emphasis is on data rather than functions.
✓ Objects may communicate with each other through functions.
✓ New data and functions can be easily added whenever necessary.

Parallel Processing Approach : The processing of program instructions by dividing them among
multiple processors is called parallel processing approach. It contains many number of processors with
the objective of running a program in less time by dividing them into modules. This approach follows
divide and conquer technique.
Examples : Python, MATLAB, Java, R language etc.,

Logic Programming Paradigm : It is a programming paradigm that emphasizes the use of logic and
reasoning to solve problems. It is based on the mathematical concept of predicate logic. Programs are
constructed as sets of logical rules and facts. These rules and facts are used to express the relationships
between objects.
Examples : PROLOG ( PROgramming in LOGic ) ,
Golog ( Goal Language ) specifically designed for robotics and artificial intelligence
applications,
Datalog, Mercury etc.,
Functional Programming Paradigm : Functional programming is a programming paradigm where
software application focuses on development of functions. The Functional Programming paradigm views
all subprograms as functions. They accept zero or multiple arguments and return a single value. It is a
powerful paradigm that is well-suited to a wide range of applications such as data processing, web
development and scientific applications.

Examples : Haskell, Lisp, ML, Scala etc.,

Database/Data driven programming approach : In this approach, the database is the primary data
storage and the application is designed to interact with the database to retrieve and manipulate the data.
This approach is mainly used in web applications, where data is stored in a database and accessed through
a web interface. A database program is the heart of business information system and provides file
creation, data entry, update, query and reporting functions.
Examples : Oracle, MySQL, Microsoft SQL Server etc.,

Software design paradigm : A software paradigm refers to a fundamental approach or methodology

for designing, developing and maintaining software. It is a set of principles, concepts and practices that
guide software development and determine how software is designed, implemented and tested.

Event-Driven Programming : EDP is a paradigm that emphasizes designing software systems that
respond to events or messages. In an Event-Driven program, when an event occurs the program responds
by executing a corresponding event handler. The software system is designed as a set of loosely coupled
components, where each component responds to events generated by other components. These
components are developed independently, tested separately and modified without affecting the rest of the
system.

Model-Driven Development : MDD is a software design paradigm that focuses on creating software
systems through the use of models. The developers create models that represent various aspects of the
software system, including its functionality, structure, behavior, user interfaces etc., These models can be
created using Unified Modeling Language (UML).
Once these models are created, they can be used to generate the code that make up the software
system. They use automated tools such as model-to-code generators, which take the models as input and
produce executable code as output. MDD improves the productivity and the quality of the software
development while reducing the risk of errors and inconsistencies.
 10

Service-Oriented Architecture : SOA is a software design paradigm that emphasizes the use of
services as the building blocks of a software system. It focuses on the development of loosely coupled,
interoperable services that can be combined to form complex applications.

Software development Paradigm : The Software development paradigm is a theoretical framework that
serves as a guide for the development and structure of a software system. It is also known as software
engineering.

Each paradigm has its own strengths and weaknesses, and choosing the right one depends on the
problem domain, the available tools, the goals and specific requirements of the software project.

Software Engineering Process Models

Definition : Software Process is a coherent set of activities for specifying, designing, implementing and
testing software systems. A software process model is an abstract representation of the development
process.
The goal of a software process model is to provide guidance for controlling and coordinating the
tasks to achieve the quality end product. Software processing models refer to the different approaches
and methodologies that are used to design, develop and deploy software applications.

There are several software processing models that are commonly used in the software development industry.
Some common software processing models include:

1. Waterfall model : This is a linear sequential model where the development process is divided into
different phases such as requirement gathering, design, development, testing, and maintenance. This
model follows a sequential process where each phase must be completed before moving to the next
phase.

2. Spiral Model : The spiral model is a risk-driven process model that combines elements of the
waterfall model and the iterative model. The development process is divided into a series of smaller
cycles called spiral. It looks like a spiral with many loops. The exact number of loops of the spiral is
unknown and can vary from project to project. The exact number of phases needed to develop the
product can be varied by the project manager depending upon the project risks.

Spiral model follows the following four phases :

 11

o Objective Identification
o Alternative Evaluation
o Product Development
o Next Phase Planning

3. Prototype Model : An initial version of the software system that can be used to obtain feedback
from users and stakeholders, which can then be used to refine and improve the system, is called
Prototype. The prototype model is an iterative process, where multiple prototypes are developed and
refined until the final product meets the desired requirements.
The following are the different categories of prototypes.
• Rapid Throwaway Prototype
• Evolutionary Prototype
• Incremental Prototype
• Extreme Prototype.

4. Iterative model : The Iterative model is similar to the Agile model, in that it involves an iterative
approach to software development. The Iterative model consists of a series of iterative cycles, with each
cycle consisting of planning, design, implementation, and testing. The Iterative model emphasizes
feedback and adaptation, and is often used in complex software development projects.

5. Incremental Model : This is a model where the software development process is broken down into
smaller increments or modules. Each module is developed and tested separately, and then integrated into
the overall system. It is an iterative process model where software is developed in small increments or
iterations. Each increment builds on the previous one, adding more functionality until the software is
complete. This allows early testing and feedback and ensures that the software is delivered in smaller,
more manageable pieces.

6. RAD model : This is a Rapid Application Development model that emphasizes rapid prototyping and
user feedback. It involves an iterative and incremental approach to software development where the
focus is on delivering working software quickly.

7. V-Model : The V-Model is a variation of the Waterfall model, where testing is integrated throughout the
development process. The V-model consists of a series of phases, including requirements analysis,
design, implementation, testing, maintenance and deployment. Each phase has a corresponding testing
phase that verifies and validates the work done in that stage. It ensures that the software meets the
requirements of the previous phase. This ensures that defects are caught early in the development
process.

8. Agile Model : This is an iterative and incremental approach to software development. It emphasizes
flexibility, collaboration, rapid delivery and customer satisfaction. Main objective is on delivering
working software quickly and continuously. It involves breaking the project down into small,
manageable parts, and continuously delivering working software. The software development process is
divided into short cycles called iterations, where each iteration results in a working software product.
Each involves in planning, designing, testing, and releasing a working software product.

These software process models have their own strengths and weaknesses. The choice of model depends on
the specific requirements of the project, team capabilities, and customer needs.

Waterfall Model

The Waterfall Model is software process model developed by Dr. Winston Royce in 1970. It is also called
as a linear-sequential life cycle model. It consists of several distinct phases, where each phase must be
completed before moving on to the next phase. There is no overlapping in the phases.
 12

The model is called “waterfall” because the output of one phase serves as the input for the next
phase, and the process flows in a downward direction like a waterfall. It follows iterative and flexible
approaches, as progress flows largely in one direction (“downwards” like a waterfall) through the phases of
requirements gathering, analysis, design, construction, testing, deployment and maintenance.

The typical phases of the Waterfall model are :

1. Requirements gathering and Analysis

2. System Design
3. Implementation ( Coding )
4. Testing
5. Deployment
6. Maintenance

Requirement Analysis : The requirements gathering and analysis is the first phase in the first phase in the
waterfall model of software development. During this phase, the project team works with the stakeholders
(End-users, Managers, Directors etc., ) to identify and document the requirements for the software project.

This phase involves the following activities :

o Understanding the project goals and objectives
o Understanding the constraints of the proposed system
o Identifying User requirements
o Defining the scope of the project
o Creating a Software Requirements Specification (SRS) Document

System Design : This phase is a critical part, as it sets the foundation for the development of the system.
The design document serves as a blueprint for the developers. It describes the overall system architecture,
the different components of the system and how they interact with each other. The design document serves
as a roadmap for the developers, providing them with a clear understanding of the system architecture and
functionality, and guiding them in the implementation phase.
 13

The design phase involves several key activities :

o Defining the system architecture
o Developing a detailed functional specification
o Creating a design document
o Identifying potential risks and constraints

Implementation : The implementation phase is an important phase, where the software takes shape and
becomes a functioning system. During this phase, the software is developed based on the detailed design
document that was created during the design phase. The development team starts coding using programming
languages and tools that are appropriate for the project. The developers must ensure that software is
developed according to the design document and must meet the requirements specified in the SRS (Software
Requirements Specification).

Testing : Testing is a crucial part of the waterfall model, and it is typically done after the implementation
phase. Testing is an iterative process, if any defects are found during testing, they are reported to the
development team, who fixes the issues and re-tests the software. This process continues until the software
meets all the requirements. Once the software has been successfully tested and approved, it can be released
to the end-users.
• Unit testing involves testing individual components of the software.
• Integration testing involves testing the interactions between different components of the software.
• System testing involves testing the entire system as a whole and ensures that it meets all
requirements.
• Acceptance testing involves testing the software with real users.

Deployment : The deployment phase is the key stage in software development process. During this phase,
the software is packaged and prepared for release.
The key activities carried out during this phase include :
o Installation Manuals and configuration procedures are documented.
o The software development teams works closely with the operations team to ensure the software can
be easily deployed.
o Training manuals and necessary support is provided to the end-users.

Maintenance : The maintenance phase is the final phase in the waterfall model of software development.
The software is continuously monitored and updated to ensure that it remains effective and efficient over
long term.
The key activities carried out during this phase include :
o Bug fixing and troubleshooting
o Updates and enhancements
o User support
o Performance optimization

Advantages :
✓ Waterfall model is suitable for software projects that have
o Well-defined set of requirements and
o scope of the project is stable and fixed.
✓ It is particularly useful for large, complex projects where there is need for detailed planning and
documentation.
✓ It provides clear milestones and deliverables, which makes it easier to track progress and identify any
issues or delays.
✓ It places emphasis on documentation (such as requirements documents and design documents) as well as
source code.

Disadvantages :
✓ It requires significant amount of planning and documentation, which can be time-consuming and lead to
inefficient use of resources.
 14

✓ Requirement gathering and analysis phase involves collaboration with the customer, but there is limited
customer involvement throughout the rest of the project.
✓ It may not be the best choice for projects where there is changing requirements.
✓ Change in requirements lead to re-design, re-development, re-testing and increased costs.
✓ The waterfall model should move to next phase only when its preceding phase is reviewed and verified.
✓ In less thoroughly designed and documented methodologies, knowledge is lost if team members
leave before the project is completed, and it may be difficult for a project to recover from the loss.
✓ If a fully working design document is present, new team members or even entirely new teams should
be able to familiarize themselves by reading the documents.

Iterative Model
An iterative model is a type of incremental model that involves repetitive processes or steps in
order to develop a software product. The development process is broken down into smaller iterations, and
each iteration focuses on a specific set of tasks. Each iteration consists of Design, Development, Testing and
Review being incorporated into subsequent iterations. The remaining phases, Requirement Gathering and
Analysis, Deployment and Maintenance are one time and doesn't involve in iterations.

In the iterative model, each iteration is a mini-waterfall process that follows the same steps as the
traditional waterfall model. Each iteration is a self-contained project, the output of one iteration is used as
the input for the next iteration.

Requirements Gathering : The development team gathers initial requirements from stakeholders using
techniques such as interviews, surveys and workshops etc., They ensure that all requirements are complete,
consistent and unambiguous. They create a requirements document that outlines all requirements
(Functional and Non-functional ) for the software product.

Analysis : The Analysis phase involves gathering and analyzing information about the client’s
requirements, goals and objectives of the software product. Once the system analysis phase is complete, the
development team moves on to the design phase.
 15

After Analysis phase, the iterative development process begins with each iteration consisting of Design,
Deployment, Testing and Review.

Design : The design team creates an architectural design that defines the overall structure of the software
product. It includes system’s components, their interactions and the interfaces between them. They also
create a user interface design that defines how the user will interact with the software product. They create a
database design that defines the structure of the database, including the tables, fields and relationships.

Development : The development process in the iterative model is broken down into a series of iterations.
The software product is developed in increments. Each iteration includes a set of development tasks, which
are carried out by the development team.

Testing : Testing is performed in each iteration to ensure that the product meets the required quality
standards. It is an ongoing process that starts from the first iteration and continues until the final product is
delivered.

Review : During this phase, the development team and stakeholders evaluate the product to determine
whether it meets the specified requirements and whether any changes or improvements are needed. Once the
review phase is complete, they move on to the next iteration, incorporating any necessary changes or
improvements in the next cycle of development. The review phase is repeated for each iteration until the
final product is achieved.

Deployment : The deployment refers to the process of releasing the software product to users after it has
been tested and reviewed. It ensures that the software product is installed, configured and operational in the
target environment.

Maintenance : Maintenance plays a crucial role ensures that software product continues to function
effectively after it has been deployed.
Corrective maintenance : Involves fixing defects or errors that are discovered after software release.
Adaptive maintenance : It involves changes in hardware or operating systems.
Perfective maintenance : It involves improving software functionality, usability without changing
structure.
Preventive maintenance : It involves steps to prevent future problems or defects.

Advantages :
✓ Product is built and improved step by step. So, defect tracking is possible in early phases.
✓ Allows for frequent review from the customer, lead to increased customer satisfaction.
✓ Debugging and testing in a smaller iteration would be easy.
✓ The development team can adapt to changing requirements and respond to feedback from the
customer.
✓ Parallel development can be planned.
✓ It promotes communication and collaboration among team members.
✓ More suitable for agile organizations.

Disadvantages :
✓ Project completion date is not known at the beginning which is a risk.
✓ More resources required.
✓ Not all requirements are gathered in the beginning of the software project.
✓ Limited time spent on documentation and extra time on design.
✓ Not suitable for smaller projects.
✓ Phases overlapping not supported.
 16

Spiral Model
The Spiral Model is an iterative software development model that emphasizes risk management throughout
the entire development process. The Spiral Model is a software development process model that combines
elements of both the waterfall model and iterative model. It was introduced by Barry Boehm in 1986 and is
often used in large, complex projects where uncertainty and risk are high.

Risk analysis :
Spiral model is a risk-driven process model, the overall success of a project highly depends on the risk
analysis. It looks like a spiral with many loops. The exact number of loops of the spiral is unknown and can
vary from project to project. The exact number of phases needed to develop the product can be varied by the
project manager depending upon the project risks.

✓ It can be used for projects of all sizes and types.

✓ The spiral model is particularly useful for large, complex projects where requirements and priorities
may change over time.

Spiral Model - Iteration :

✓ The Spiral model divides the software development process into a series of cycles. Each cycle is
called Iteration.
✓ Each iteration includes
o risk management, prototypes,
o design, code, integration,
o test and implementation.
✓ The prototype is evaluated to determine if it meets the requirements of the stakeholders.
✓ If the prototype is satisfactory, the development team moves on to the next iteration, where they
focus on enhancing and improving the software.
✓ If the prototype is unsatisfactory, the team goes back to the Planning phase and starts the
iteration again.
✓ It consists of a series of iterative cycles, each of which is divided into four phases.

Spiral Model - Quadrants :

The Spiral model is a software development methodology that divides the development process into four
quadrants. Each quadrant represents a specific set of activities.
 17

The four quadrants of the Spiral model are:

Objective Identification (or) Determine Objectives : It is the first quadrant in the Spiral model. The
Objective Identification quadrant is critical to the success of the project and it sets foundation for the rest of
project.
The main objective of this quadrant is
o identify the objectives of the project,
o defining requirements and constraints and
o establishing a plan for achieving those objectives.
In this quadrant, the project scope is defined and the risks associated with the project are identified.

Alternative Evaluation Phase : This is the second quadrant that comes after the Objective Identification
quadrant. The development team creates and evaluates different solutions that address the project goals and
objectives. It includes developing prototypes, models or simulations to test different solutions. They identify
the risks associates with each alternative and evaluates the trade-offs between different solutions.
This quadrant involves the following steps :
o Generate Alternatives
o Evaluate Alternatives
o Identify Risks
o Review and Select Solution

By evaluating alternative solutions, the development team can identify the most feasible solution for
producing high quality software product.

Product Development : It is the third quadrant in the Spiral Model. It comes after the Alternative
Evaluation quadrant. It is critical to the success of the project, as it involves in the actual development and
implementation of the software. This involves coding, testing, integrating different components and
validating the software to ensure that it meets the objectives and requirements identified in the first quadrant.
It involves creating detailed specifications and design documents that outline the functionality,
architecture and features of the product. The development team reviews the product and gathers
feedback from stakeholders. The team uses this feedback to improve the product and make any
necessary changes before moving on to the next quadrant.

This quadrant involves the following steps :

o Design
o Implementation
o Verification and Validation
o Review and Feedback

Next Phase planning :

NPP quadrant is the final quadrant in the Spiral model. It comes after the Product Development Quadrant. It
allows users for continuous improvement and ensures that the project is always moving forward in an
efficient way.
This quadrant involves the following steps :
o Review
o Plan
o Risk Analysis
o Review and Feedback
This quadrant involves reviewing the software development process and evaluating the results. The focus is
on identifying any areas where improvements can be made and developing a plan for implementing those
improvements in future software development projects.
 18

Advantages :
✓ The spiral model is more effective in managing risks associated with software development projects.
✓ It follows an iterative approach, which is very flexible and adaptable, so they can be modified to meet
changing requirements.
✓ It encourages customer involvement and feedback throughout the development process. This
ensures that the final product meets the customer's needs and requirements.
✓ It identifies the potential problems before they become major issues.
✓ It is highly flexible and can be customized to suit the specific needs of stakeholders.
✓ It helps in delivering high-quality products, as it emphasizes testing and quality assurance throughout the
development process.

Disadvantages :
✓ The spiral model is not suitable for smaller projects and with limited resources.
✓ The success of the spiral model is heavily dependent on the accuracy of the risk analysis conducted
at each iteration.
✓ It requires lot of planning, analysis and risk management.
✓ It the risks are not identified or managed properly, it can lead to significant problems.
✓ It is more expensive than other software development process models.
✓ It is time-consuming, each iteration can take a significant amount of time to complete.

Rapid Application Development

Rapid Application Development (RAD) is an agile software development approach that emphasizes
rapid prototyping and iterative development. It was developed by James Martin in 1980. Today, RAD is
used by many software development teams to speed up the development process and deliver high-
quality software that meets the needs of the stakeholders.
A prototype is a working model of the software application that is used to test and refine the design.

✓ RAD follows a model-driven approach, where the focus is on developing software prototypes that
can quickly modified based on feedback from end-users.
✓ RAD is useful in situations where speed, collaboration and flexibility are important.
✓ RAD tools provide graphical user interfaces, drag-and-drop components and code generators that help
developers create software applications quickly and easily.

RAD Tools Builds Applications

Alpha Software Windows, Web, Mobile
Appian Web, Mobile
Salesforce AppCloud Web, Mobile
Kony Web, Mobile
Mendix Web, Mobile
OutSystems Web, Mobile
WaveMaker Web, Mobile
 19

Rapid Application Development (RAD) Model :

The five phases of the Rapid Application Development (RAD) are :

1. Business Modeling : The goal of business modeling is to identify the key business processes and
requirements of the system and to develop a high-level view of how the system will support the business.
This phase includes the following tasks :
o Identify the business processes
o Develop a high-level view of the system
o Identify system requirements
o Create a prototype
o Refine the model

2. Data Modeling Phase : The main objective of this phase is to create a data model for the proposed
system. It serves as a blueprint for the database design and ensures that the software system will meet the
requirements of the stakeholders.
This phase includes the following activities :
o Identifying data entities,
Ex : Order processing system has entities such as Customers, Orders, Products and Employees
o define attributes
Ex :Customer entity has attributes such as custid, name, address, mobile, email etc.,
o identifying relationships such as customers, orders, products and employees
Ex : A “Customer” can place multiple “orders” and An “Order” may have multiple “products”.
o Creating an Entity-Relationship (ER) diagram
o Normalizing the data model
o Creating a Physical data model
o Defining data constraints
o Creating data dictionary
o Reviewing and refining the data model

3. Process Modeling Phase : In this phase, business analysts and the developers work together to create
detailed process flow diagrams and data models that provides a clear blueprint for the
development team. This phase is a key component in the RAD methodology and ensures the success
of the project.
The phase includes the following activities :
o Defining the project scope
 20

o Identifying the business processes

o Creating process flow diagrams
o Creating a data model
o Creating a prototype
o Reviewing and Refining the model

4. Application Modeling Phase : In this phase the actual application software is developed using the
requirements gathered in the previous phases. The development team uses various tools such as visual
programming languages, code generators and CASE (Computer Aided Software Engineering) tools to
speed up the development process and ensures that it meets the functional requirements of the end-users.

This phase includes various activities such as :

o Creating a functional prototype
o Refining the prototype
o Developing the software
o Testing the software

5. Testing Modeling Phase : It is an important phase that occurs after the Application Modeling Phase. It
helps to ensure that the developed application is of high quality and meets the end-user’s requirements.
Testing is carried out at different levels. It involves various types of testing including unit testing,
integration testing, system testing and acceptance testing. Once testing phase is complete, the software is
handed over to the end-users for deployment. The turnover phase involves documenting the software,
preparing user manuals, technical manuals, provide support for maintenance and future development.

RAD - Advantages :
✓ RAD allows for faster development of software applications, because it focus on rapid prototyping,
iterative development and concurrent testing.
✓ RAD is suitable for projects with a high degree of uncertainty or ambiguity.
✓ It enables stakeholders to see working version of the system.
✓ RAD encourages close collaboration between stakeholders, developers and testers.
✓ RAD is a flexible methodology that allows developers to make changes quickly and easily.

RAD - Disadvantages :
✓ The software developed using RAD model can be more complex than software developed using
traditional methodologies.
✓ RAD is ideal for smaller-scale projects, but it may not be suitable for larger and more complex
projects.
✓ RAD requires a highly skilled development team with expertise in multiple areas.
✓ The fast-paced, iterative nature of RAD can lead to a higher risk of errors and bugs, which can
impact the quality of the product.
✓ RAD often prioritizes speed over documentation, which can result in a lack of clear documentation
or technical specifications.
✓ This can make it difficult for other developers to maintain or modify the software over time.
 21

Waterfall model RAD model

Waterfall model is also known as RAD stands for Rapid Application Development.
Classical/Traditional model.
There is high amount of risk. There is low amount of risk.
It requires large team size. It requires small team size.
Any changes can be made in waterfall model only at Any changes can be made in RAD model anytime.
the beginning.
The product is delivered after the completion of all Product of RAD will be delivered very quickly.
stages.
There is long waiting time for running software. There is less waiting time for running software, its
first version is released as soon as possible.
Waterfall model is not compatible with the change in RAD model may work with the change in client
client requirements. requirements.

Prototype Model

Prototype : An initial version of the software system that can be used to obtain feedback from users
and stakeholders, which can then be used to refine and improve the system, is called Prototype. The
prototype model is an iterative process, where multiple prototypes are developed and refined until the final
product meets the desired requirements.

The prototype model is a software development methodology that emphasizes the creation of a working
model of a software system to demonstrate its functionality to users and stakeholders.
 22

Types of Prototypes :
The following are the different categories of prototypes.
• Rapid Throwaway Prototype
• Evolutionary Prototype
• Incremental Prototype
• Extreme Prototype.

Requirements Gathering : During the requirements gathering phase, the development team works closely
with the stakeholders to identify and document the system's functional and non-functional requirements.
These requirements may include features, usability, performance, reliability and other factors that are
important for the success of the software system.

Quick Design : Development team develops the initial prototype of the system with basic requirements.
These features are used in quick design and it may not work exactly in the same manner as the final
software product. The overall look and feel would be same as the original product.

Building prototypes : The primary goal of building a prototype is to test and validate the requirements
before investing significant time and resources into the final product. It's important to keep the prototype
simple, functional and easy to test.

Customer Evaluation : Once the prototype build, it must be sent to customer, stakeholders and clients
for the review. Clients check for the functionality and gives feedback to the development team.

Customer Feedback : Gathering feedback from users and stakeholders, can help to identify common
issues, refine the design and improve the overall user experience. If any review comments or any
improvement suggestions, the development team has to take them and move to quick design phase again.

This feedback helps the developers and designers work on the prototype to incorporate feedback
comments. Once the design modified, again sends for client review. This process will continue
until no review comments from client or gets a client signoff to proceed with design and development.

Design : It is an important phase where the requirements gathered are transformed into a detailed plan for
creating the software. The goal of design phase is to create a blueprint that outlines how the software will
function, how it will be implemented, and how it will meet the user's needs.

Coding : The goal of coding is to create a software application that can perform a specific set of tasks.
Coding is the process of writing instructions in a particular programming language. It is also known as
programming.

Testing : Testing plays a crucial role in ensuring the quality and reliability of the software. During the
testing phase, the focus is on verifying the functionality of the software and identifying any defects or issues
that may affect the software system.

Deployment : The deployment phase is critical to the success of the software system. It typically follows
the testing phase. Deployment refers to the process of making the software application work on a target
device, it may be a test server, production environment or user's computer or mobile device.

Maintenance : It is an important aspect that ensures the prototype is functioning properly and meets the
expectations of stakeholders.

Advantages :
✓ Easy to detect errors in the initial stage.
✓ Flexibility in designing.
✓ Helps in effective team communication.
✓ Easy to identify the missing functionality.
 23

✓ Quicker feedback from client helps for better solutions.

✓ Encourages innovation.

Disadvantages :
✓ It is not suitable for small businesses or startups having limited resources.
✓ Documentation is poor.
✓ The process of building a prototype can be time-consuming, if the prototype needs to be developed
and tested multiple times.
✓ Developing multiple prototypes can be costly and slow down the overall development process.
✓ It leads to delays in product launch.
✓ If the prototype is rejected, cost of design and developing prototype becomes waste.
✓ Large amount of change requests are accepted.

Types of Requirements

Definition : The functional and non-functional specifications that the software system must satisfy in
order to meet the needs of its users and stakeholders are called software requirements. The requirements
are identified during the software development process through collaboration between the project team and
stakeholders. These requirements serve as the foundation for the entire software development
process and provide a clear understanding of proposed system, ensuring that all stakeholders have a
shared vision of the project.
The process of defining software requirements involves identifying the needs of all stakeholders,
including end-users, customers, managers and developers. This involves gathering, analyzing,
prioritizing, and documenting the requirements in a clear, concise, and organized manner.
The software requirements play a critical role in ensuring the success of software development
projects to ensure that the final product meets the needs of its users, is delivered on time and within
budget and of high quality.

Types of requirements : The requirements can be classified as follows.

1. Functional requirements
2. Non-functional requirements
3. Business Requirements
4. User requirements
5. System requirements
6. Interface requirements
7. Domain requirements
8. Performance requirements
9. Inverse requirements
10. Regulatory requirements
1. Functional Requirements : The requirements that guide the developer / software team how to
implement the negotiated requirements are called functional requirements. Such requirements
must be implemented by use cases. They describe the specific tasks that the software system must
perform, such as user interfaces, data inputs and outputs, data processing, and data storage. These
requirements typically include details such as the inputs, outputs, and data flows for each function, as
well as any constraints or assumptions that apply.
Examples : Teacher should be able to change marks of student.
The system should display attendance of a particular student.
The student should be able to download notes from the system.
 24

2. Non-functional requirements : The requirements that does not support functional requirements are
called non-functional requirements. They describe the quality attributes of the software system, such as
performance, scalability, reliability, and security.

Way to write Non-functional requirements :

Wrong Way :
• The system should be fast.
• The system should be reliable.
• The system should run on low memory devices.
• The system should store a large amount of data.
• The system should be able to run on famous operating systems.
• The system should load a web page quickly.

Right Way :
• The system should respond in less than 2 seconds.
• The system should be available to the user without any crash.
• The system should run on devices having RAM lower than 1GB.
• The system should store data upto 300GB.
• The system should be able to run on Windows, Linux and Mac OS.
• The system should load a web page within 2 seconds.

Classification of non-functional requirements :

o Product requirements : Requirements related to the product attributes or quality are called
product requirements.
Ex : Efficiency, Reliability, usability etc.,
o Organizational Requirements : Requirements related to the organization needs or standards are
called organizational requirements.
Ex : Implantation and standards of an organization
o External Requirements : Requirements that come from some outside factors are called external
requirements.
Ex : Government rules that system should not violate.

Business Requirements : They specify high level goals and objectives and needs of a business that must
satisfy by the software system.
Ex : Increase Sales Revenue by 20% within the next year.

User requirements : They specify the needs and expectations of the end users such as the tasks they need
to perform, the information they need to access and the user interface they must prefer etc.,
Ex : They should provide clear and informative feedback to users when errors or issues occur.

System Requirements : They specify the technical requirements of the system including the hardware,
software and network infrastructure needed to support the system’s functionality.
Ex : The system must be able to operate within specific hardware requirements such as processor speed,
memory and storage capacity.

Interface requirements : They describe the specifications and capabilities of user interface of the
software system.
Ex : The system must be responsive to user inputs with buttons and menus that are easy to click & navigate.
Domain requirements : The requirements that are specific to the domain in which the software system
will be implemented are called domain requirements. They describe the specific characteristics and
constraints of that particular domain.
Ex : In Health Care Management System, the system should allow the patients to access their medical
records and communicate with their healthcare providers.
 25

Performance requirements : They specify the system’s performance characteristics such as response
time, throughput and scalability.
Ex : The system maintains good performance, the application can handle high network traffic growth.

Inverse Requirements : Those requirements that describe what the system should not do are called
inverse requirements. They are used to specify constraints and limitations on the software system’s behavior.
Ex : In Banking Application, the system should not allow the users to withdraw more than their available
balance.

Regulatory Requirements : They specify the legal requirements that the system must follow in terms of
data privacy laws, security standards and accessibility.
Ex : The system must describe the labor laws and regulations with minimum working hours.

By identifying and addressing these different types of requirements, software developers can ensure that the
software system they are building meets the needs and expectations of all stakeholders, customers, internal
as well as external users.

Requirement Analysis
The requirement analysis is a critical step in ensuring the success of a software development project. It helps
to ensure that the final product meets the needs of its users, is delivered on time and within budget and is of
high quality.

A Business Analyst is a member of software requirement team whose job is to elicit, analyze,
document, validate and pass the requirements to other team members. He acts as a bridge between the
customer and the development team.

Requirement analysis is critical to the success or failure of software project. It ensure that the final product
meets the needs of its users and also ensures that it is designed and implemented in efficient and effective
manner. The Requirement Analysis typically involves the following steps:

Eliciting requirements (or) Gathering Requirements : Gather requirements from all stakeholders
(users, customers and subject matter experts etc., ) using techniques such as interviews, surveys, workshops
etc., Document these requirements in a consistent and organized manner.
Analyzing requirements : Requirements are analyzed to identify any conflicts, inconsistencies or missing
information. It involves breaking down the requirements into manageable pieces, identifying any conflicts or
ambiguities, and prioritizing the most important requirements.
 26

Specifying requirements (or) Documenting the requirements : This involves documenting the
requirements in a clear, concise manner and organized manner, using standardized formats such as use
cases, user stories and functional requirements documents. This helps ensure that everyone has a shared
understanding of the requirements that were negotiated.

Organize the requirements : Organize the requirements in a logical and consistent manner, using
heading, subheadings and bullet points to improve readability.

Validating requirements : Review the requirements with stakeholders and validate them to ensure that
they are complete, accurate and meet the needs of all stakeholders. Test the requirements against real-world
scenarios and verifying that they meet the needs of the business and its users.

Prioritize requirements : Prioritize the requirements based on their importance and relevance to the
project goals. This helps identify the requirements that are most critical and need to be negotiated.

Negotiating Requirements : Negotiating requirements is a critical activity in software development

process, as it helps ensure that all stakeholders’ needs are met and the project is feasible and can be
successfully implemented.

Requirements Elicitation Techniques :

1. Brainstorming :
This technique is used to generate new ideas and find a solution for a specific issue. The members
included for brainstorming can be domain experts, subject matter experts. Multiple ideas and
information give you a repository of knowledge and you can choose from different ideas.
Brainstorming technique is used to answer the below questions :
• What is the expectation of a system?
• What are the risk factors that affect the proposed system development?
• What are the business and organization rules required to follow?
• What are the options available to resolve the current issues?
• What should we do so that this particular issue does not happen in the future? -
There are some basic rules for this technique which should be followed to make it a success:
• The time limit for the session should be predefined.
• Identify the participants in advance.
• One should include 6-8 members for the session.
• The agenda should be clear enough for all the participants.
• Once you get all the information, combine the ideas, and remove the duplicate ideas.
• Once the final list is ready, distribute it among other parties.
 27

Benefits :
• Creative thinking is the result of the brainstorming session.
• Plenty of ideas in a short time.
• Promotes equal participation.
Drawbacks :
• Participants can be involved in debating ideas.
• There can be multiple duplicate ideas.

2. Interview : If the interviewer has a predefined set of questions then it’s called a structured
interview. If the interviewer is not having any particular format or any specific questions then it’s
called an unstructured interview. Interview techniques should be used for building strong relationships
between business analysts and stakeholders. The interviewer directs the question to stakeholders to
obtain information. One to one interview is the most commonly used technique.
Basic Rules : The overall purpose of performing the interviews should be clear. Identify the
interviewees in advance. Interview goals should be communicated to the interviewee. Interview
questions should be prepared before the interview. The location of the interview should be predefined.
The time limit should be described. The interviewer should organize the information and confirm the
results with the interviewees as soon as possible after the interview.
Benefits :
• Interactive discussion with stakeholders.
• The immediate follow-up to ensure the interviewer’s understanding.
• Encourage participation and build relationships by establishing rapport with the stakeholder.
Drawbacks :
• Time is required to plan and conduct interviews.
• Commitment is required from all the participants.
• Sometimes training is required to conduct effective interviews.
3. Document Analysis/Review :
This technique is used to gather business information by reviewing/examining the available materials
that describe the business environment. This analysis is helpful to validate the implementation of current
solutions. It includes reviewing the business plans, technical documents, problem reports, existing
requirement documents, etc. This is useful when the plan is to update an existing system. This technique
is useful for migration projects.
Benefits :
• Existing documents can be used to compare current and future processes.
• Existing documents can be used as a base for future analysis.
Drawbacks :
• Existing documents might not be updated.
• Existing documents might be completely outdated.
• Resources worked on the existing documents might not be available to provide information.
• This process is time-consuming.
4. Interface Analysis :
Interface analysis is used to review the system, people, and processes. This analysis is used to identify
how the information is exchanged between the components. An Interface can be described as a
connection between two components.
 28

The interface analysis focus on the below questions:

✓ Who will be using the interface?
✓ What kind of data will be exchanged?
✓ When will the data be exchanged?
✓ How to implement the interface?
✓ Why we need the interface?
✓ Can’t the task be completed without using the interface?

Benefits :
• Provide missed requirements.
• Determine regulations or interface standards.
• Uncover areas where it could be a risk for the project.
Drawbacks :
• The analysis is difficult if internal components are not available.
• It cannot be used as a standalone elicitation activity.

5. Observation :
The main objective of the observation session is to understand the activity, task, tools used and events
performed by others.
During the session, all stakeholders are aware of the purpose of the observation session, the observer
should record all the activities and the time taken to perform the work by others so that he/she can
simulate the same. After the session, the Business Analyst will review the results and will follow up with
the participants. Observation can be either active or passive.
Active observation is to ask questions and try to attempt the work that other persons are doing.
Passive observation is silent observation i.e. you sit with others and just observe how they are doing
their work without interpreting them.
Benefits :
• The observer will get a practical insight into the work.
• Improvement areas can be easily identified.
Drawbacks :
• Participants might get disturbed.
• Participants might change their way of working during observation and the observer might not
get a clear picture.
• Knowledge-based activities cannot be observed.
6. Joint Application Development (JAD)/ Requirement Workshops : This technique is more
process-oriented and formal as compared to other techniques. These are structured meetings involving
end-users, PMs, SMEs. This is used to define, clarify, and complete requirements.
This technique can be divided into the following categories:
Formal Workshops : These workshops are highly structured and are usually conducted with the
selected group of stakeholders. The main focus of this workshop is to define, create, refine, and reach
closure on business requirements. Business Process Improvement Workshops: These are less formal as
compared to the above one. Here, existing business processes are analyzed and process improvements
are identified.
Benefits :
• Documentation is completed within hours and is provided quickly back to participants for
review.
• You can get on the spot confirmation on requirements.
• Successfully gathered requirements from a large group in a short period.
• Consensus can be achieved as issues and questions are asked in the presence of all the
stakeholders.
Drawbacks :
• Stakeholder’s availability might ruin the session.
• The success rate depends on the expertise of the facilitator.
• A workshop motive cannot be achieved if there are too many participants.
 29

Analysis Model
Analysis Model : In object-oriented software engineering, Technical representation of the software
system is called Analysis Model. An analysis model is a representation of the requirements of a
software system that captures the needs and constraints of the stakeholders. It acts as a link between
“system description” and “design model”.

✓ It is a high-level representation of a system that is designed to capture its essential characteristics

such as its behavior, structure, and interactions with other systems.
✓ An analysis model is an essential tool for researchers, analysts and decision-makers to understand and
improve the behavior of complex systems.

Objectives of Analysis Modelling :

✓ It is developed during the requirements analysis phase of the software development life cycle
(SDLC) and serves as a basis for the design and implementation of the system.
✓ The analysis model helps to ensure that the requirements of the system are clearly defined,
understood, and they must satisfy the needs of the stakeholders.
✓ It must define a set of requirements that can be validated once the software is built.

Elements of Analysis Model :

Scenario based Element :

The analysis model typically includes use case diagrams, which describe the interactions between the system
and its users or other systems, and class diagrams, which depict the structure of the system in terms of its
classes, attributes and methods.

Behavioral Based Element :

Other diagrams, such as sequence diagrams and activity diagrams, may also be used to describe the behavior
of the system in more detail.

Class Based Element :

The class-based analysis model represents the static structure of a system by showing the classes, their
attributes, operations, and the relationships between them. The system's requirements are represented as a set
of classes and their relationships. Each class represents a concept in the system, and the relationships
between the classes represent how these concepts interact with each other.

Data Dictionary :
A data dictionary is a document or file that provides a detailed description of the entities, their attributes
and relationships used in a database. The Data Dictionary ensures consistency and accuracy of data in the
database. It can be used by data analysts, database administrators, programmers, and other stakeholders to
understand the logical structure of the given system.
 30

It typically includes information such as:

✓ Data elements or variable name

✓ Description or definition of the data element or variable
✓ Data type (e.g., Number, Varchar2, integer, character, date etc., )
✓ Data length or size
✓ Allowable values or ranges
✓ Source of the data element or variable (if applicable)
✓ Relationships (or) dependencies with other data elements or variables
✓ Metadata (or )other relevant information about the data element or variable.

Data Flow Diagram :

A Data flow diagram (DFD) is a graphical representation of a system or process that shows how data
flows within the system. DFD is a powerful tool for visualizing the flow of data within a system and
understanding how different components of the system interact with one another. They are used to analyze
existing systems, design new systems, and communicate system requirements to stakeholders.

A data flow diagram can have different levels of detail, ranging from a high-level overview of the
system to a detailed description of individual processes and data elements.

A data flow diagram typically consists of the following components:

Entities : These are external sources or destinations of data. Entities represent people,
organizations, or other systems that interact with the system being modeled.

Processes : These are activities or actions that transform the data. Processes take input data,
manipulate it and produce output data.

Data flows : These are arrows that represent the movement of data between entities, processes and
data stores. Data flows show the direction in which data moves and the format in which it is transmitted.
Data stores : These are repositories of data that are stored and maintained within the
system. Data stores represent places where data is stored and retrieved.

Entity Relationship Diagram :

An ER diagram also known as an Entity-Relationship diagram, is a graphical representation of
entities and their relationships to each other within a system. It is a modeling tool used in software
engineering, database design and business processes. ER diagrams are commonly used in database
design to illustrate the relationships between different tables in a database.

ER diagrams can be used to design new databases or to analyze existing databases.

The basic components of an ER diagram include entities, attributes, and relationships.

An entity represents a real-world object, such as a customer, product, or order.
Each entity has one or more attributes, which describe the characteristics of the entity.
 31

For example, a customer entity might have attributes such as name, address and phone number.

Entities are connected to each other through relationships, which describe how they are related to each
other. The following are the types of relationships:
one-to-one each entity is connected to only one other entity
one-to-many one entity is connected to multiple instances of another entity
many-to-one multiple instances of one entity are connected to one instance of another entity
many-to-many multiple instances of one entity are connected to multiple instances of another entity

State Transition Diagram : It represents the dynamic model, which shows changes in the state that an
object goes through during its lifetime in response to an event.
It shows various modes of behavior (states) of the system and also shows the transitions from one state to
another state in the system. It also provides the details of how the system behaves due to the consequences
of external events. It represents the behavior of a system by presenting its states and the events that cause the
system to change state. It also describes what actions are taken due to the occurrence of a particular event.

Data Object Description :

It stores and provides complete knowledge about a data object present and used in the software. It also gives
us the details of attributes of the data object present in the Entity Relationship Diagram. Hence, it
incorporates all the data objects and their attributes.

Process Specification :
It stores the description of each function present in the data flow diagram. It describes the input to a
function, the algorithm that is applied for the transformation of input, and the output that is produced. It also
shows regulations and barriers imposed on the performance characteristics that are applicable to the process
and layout constraints that could influence the way in which the process will be implemented.

Control Specification :
It stores additional information about the control aspects of the software. It is used to indicate how the
software behaves when an event occurs and which processes are invoked due to the occurrence of the event.
It also provides the details of the processes which are executed to manage events.