Software Engineering Prof :Padmini.

What is Software Engineering?

The term software engineering is the product of two words, software, and engineering.

The software is a collection of integrated programs.

Software subsists of carefully-organized instructions and code written by developers on any

of various particular computer languages.

Computer programs and related documentation such as requirements, design models and user
manuals.

Engineering is the application of scientific and practical knowledge to invent, design,

build, maintain, and improve frameworks, processes, etc.

Software Engineering is an engineering branch related to the evolution of software product

using well-defined scientific principles, techniques, and procedures. The result of software
engineering is an effective and reliable software product.

Why is Software Engineering required?

Software Engineering is required due to the following reasons:

o To manage Large software

o For more Scalability

1
Software Engineering Prof :Padmini.B

o Cost Management
o To manage the dynamic nature of software
o For better quality Management

Need of Software Engineering

The necessity of software engineering appears because of a higher rate of progress in user
requirements and the environment on which the program is working.

o Huge Programming: It is simpler to manufacture a wall than to a house or building,

similarly, as the measure of programming become extensive engineering has to step to
give it a scientific process.
o Adaptability: If the software procedure were not based on scientific and engineering
ideas, it would be simpler to re-create new software than to scale an existing one.
o Cost: As the hardware industry has demonstrated its skills and huge manufacturing
has let down the cost of computer and electronic hardware. But the cost of
programming remains high if the proper process is not adapted.
o Dynamic Nature: The continually growing and adapting nature of programming
hugely depends upon the environment in which the client works. If the quality of the
software is continually changing, new upgrades need to be done in the existing one.
o Quality Management: Better procedure of software development provides a better
and quality software product.

Characteristics of a good software engineer

 The features that good software engineers should possess are as follows:
 Exposure to systematic methods, i.e., familiarity with software engineering principles.
 Good technical knowledge of the project range (Domain knowledge).
 Good programming abilities.
 Good communication skills. These skills comprise of oral, written, and interpersonal
skills.
 High motivation.
 Sound knowledge of fundamentals of computer science.
 Intelligence.
 Ability to work in a team
 Discipline, etc.

2
Software Engineering Prof :Padmini.B

Importance of Software Engineering

The importance of Software engineering is as follows:

1. Reduces complexity: Big software is always complicated and challenging to

progress. Software engineering has a great solution to reduce the complication of any
project. Software engineering divides big problems into various small issues. And
then start solving each small issue one by one. All these small problems are solved
independently to each other.
2. To minimize software cost: Software needs a lot of hardwork and software engineers
are highly paid experts. A lot of manpower is required to develop software with a
large number of codes. But in software engineering, programmers project everything
and decrease all those things that are not needed. In turn, the cost for software
productions becomes less as compared to any software that does not use software
engineering method.
3. To decrease time: Anything that is not made according to the project always wastes
time. And if you are making great software, then you may need to run many codes to
get the definitive running code. This is a very time-consuming procedure, and if it is
not well handled, then this can take a lot of time. So if you are making your software
according to the software engineering method, then it will decrease a lot of time.
4. Handling big projects: Big projects are not done in a couple of days, and they need
lots of patience, planning, and management. And to invest six and seven months of
any company, it requires heaps of planning, direction, testing, and maintenance. No
one can say that he has given four months of a company to the task, and the project is
still in its first stage. Because the company has provided many resources to the plan
and it should be completed. So to handle a big project without any problem, the
company has to go for a software engineering method.

3
Software Engineering Prof :Padmini.B

5. Reliable software: Software should be secure, means if you have delivered the
software, then it should work for at least its given time or subscription. And if any
bugs come in the software, the company is responsible for solving all these bugs.
Because in software engineering, testing and maintenance are given, so there is no
worry of its reliability.
6. Effectiveness: Effectiveness comes if anything has made according to the standards.
Software standards are the big target of companies to make it more effective. So
Software becomes more effective in the act with the help of software engineer.

Software Evolution is a term which refers to the process of developing software initially,
then timely updating it for various reasons, i.e., to add new features or to remove obsolete
functionalities etc. The evolution process includes fundamental activities of change analysis,
release planning, system implementation and releasing a system to customers.
The cost and impact of these changes are accessed to see how much system is affected by the
change and how much it might cost to implement the change. If the proposed changes are
accepted, a new release of the software system is planned. During release planning, all the
proposed changes (fault repair, adaptation, and new functionality) are considered.
A design is then made on which changes to implement in the next version of the system. The
process of change implementation is an iteration of the development process where the
revisions to the system are designed, implemented and tested.
The necessity of Software evolution:
Software evaluation is necessary just because of the following reasons:
a) Change in requirement with time: With the passes of time, the organization’s needs and
modus Operandi of working could substantially be changed so in this frequently changing
time the tools(software) that they are using need to change for maximizing the performance.
b) Environment change: As the working environment changes the things(tools) that enable
us to work in that environment also changes proportionally same happens in the software
world as the working environment changes then, the organizations need reintroduction of old
software with updated features and functionality to adapt the new environment.
c) Errors and bugs: As the age of the deployed software within an organization increases
their preciseness or impeccability decrease and the efficiency to bear the increasing
complexity workload also continually degrades. So, in that case, it becomes necessary to
avoid use of obsolete and aged software. All such obsolete Softwares need to undergo the
evolution process in order to become robust as per the workload complexity of the current
environment.
d) Security risks: Using outdated software within an organization may lead you to at the
verge of various software-based cyberattacks and could expose your confidential data
illegally associated with the software that is in use. So, it becomes necessary to avoid such
security breaches through regular assessment of the security patches/modules are used within
the software. If the software isn’t robust enough to bear the current occurring Cyber attacks
so it must be changed (updated).
e) For having new functionality and features: In order to increase the performance and fast
data processing and other functionalities, an organization need to continuously evolute the

4
 Software Engineering Prof :Padmini.B

software throughout its life cycle so that stakeholders & clients of the product could work
efficiently.

Laws used for Software Evolution:

1. Law of continuing change:

This law states that any software system that represents some real-world reality undergoes
continuous change or become progressively less useful in that environment.
2. Law of increasing complexity:
As an evolving program changes, its structure becomes more complex unless effective
efforts are made to avoid this phenomenon.
3. Law of conservation of organization stability:
Over the lifetime of a program, the rate of development of that program is approximately
constant and independent of the resource devoted to system development.
4. Law of conservation of familiarity:
This law states that during the active lifetime of the program, changes made in the
successive release are almost constant.

Emergence of Software Engineering

Early Computer Programming (1950s):

- Programs were being written in assembly language.

- Programs were limited to about a few hundreds of lines of assembly code.

Every programmer developed his own style of writing programs:

- according to his intuition (exploratory programming).
High-Level Language Programming (Early 60s)

5
 Software Engineering Prof :Padmini.B

High-level languages such as FORTRAN, ALGOL, and COBOL were introduced:

- This reduced software development efforts greatly.
Software development style was still exploratory.
- Typical program sizes were limited to a few thousands of lines of source code.
Control Flow-Based Design (late 60s)

Size and complexity of programs increased further:

- exploratory programming style proved to be insufficient.
Programmers found:
- very difficult to write cost-effective and correct programs
- programs written by others very difficult to understand and maintain.

To over come with this problem, experienced programmers advised: ``Pay particular attention
to the design of the program's control structure.'’
A program's control structure indicates:
- the sequence in which the program's instructions are executed.
To help design programs having good control structure:
- flow charting technique was developed.
 Using flow charting technique:
- one can represent and design a program's control structure.
- Usually one understands a program:

· by mentally simulating the program's execution sequence

A program having a difficult(messy) flow chart representation:

- difficult to understand and debug.
It was found:
- GO TO statements makes control structure of a program messy(difficult, unorganized)
- GO TO statements alter the flow of control arbitrarily.

- The need to restrict use of GO TO statements was recognized.

 Many programmers had extensively used assembly languages.

- JUMP instructions are frequently used for program branching in assembly languages,
- programmers considered use of GO TO statements inevitable.

 But, soon it was conclusively proved:

- only three programming constructs are sufficient to express any programming logic:
· sequence (e.g. a=0;b=5;)

· selection (e.g.if(c=true) k=5 else m=5;)

· iteration (e.g. while(k>0) k=j-k;)

 Everyone accepted:

6
 Software Engineering Prof :Padmini.B

- it is possible to solve any programming problem without using GO TO statements.

This formed the basis of structured programming methodology.

Software Development Project

 A software development project is a complex undertaking by two or more persons

within the boundaries of time, budget, and staff resources that produces new or
enhanced computer code that adds significant business value to a new or existing
business process.

9-Step Planning Guide for Software Development Projects

As a tech lead or software engineering manager, you’re already familiar with all these
different stages of the software development life cycle. That’s pretty much the same steps as
those for any software product, no matter the chosen process.

After all, you’re responsible for your team’s performance, the quality and efficiency of the
delivered software, and the communication with stakeholders and alignment of engineering
goals with business initiatives.

So, what are the steps to start a software project? The first one – planning everything.

1. Project Analysis

This is the first step of the scoping stage of a software project requested by a customer. It has
a lot to do with the feasibility of the project.

This analysis part is to make sure you’re starting on the right foot, and it means looking into:

 A deeper understanding of the purpose of the project (concept and goals)

 Also, a deeper understanding the needs of the project
 The project specifications.

Most of the time, it takes place at the same time as the requirements and the main planning
phase, since they’re all connected.

7
 Software Engineering Prof :Padmini.B

2. Requirements

As you move on to the third step in planning and continue to complete the scope of the
project, your development team and you start to document the technical
requirements needed to successfully deliver the software product.

In this stage, your tasks are to:

 Decide on the team responsible for the development

 Decide on the requirements
 Decide on the milestones that would work as checkpoints for testing and feedback rounds
(they answer to: “how’s the project going?”)

Together with your team, you’ll answer specific questions about the technical aspects of the
project, such as: what issue does the project solve? Who’s the end user? What sort of data is
needed? Does it need certain integrations? How is security tackled?

By answering these questions, you will be able to describe and document the technical
specifications and requirements, methods of testing, technology stacks, software and
hardware, as well as the type of methodology (you might start sprint planning, if you’re using
Agile).

Part of this planning stage is also the risk assessment, making sure that you’re also
understanding the constraints or risks the project might have.

8
 Software Engineering Prof :Padmini.B

3. Planning

Planning is the most meticulous and critical part of the project. It’s also part of the project
scope that allows everyone a clear understanding of the timeline from ideation to
deployment.

 A clear overview over the timeline ensures a better organization and synchronization of
everyone involved.
 By breaking down work into tasks, subtasks and steps you will take and looking at the
resources needed, you can provide a clearer estimate of the time and budget.
 You can use a Gantt chart, a list or, better yet, a software tool to visualize this timeline plan
and track it smoothly.

If there’s an issue, you can pinpoint and solve it more easily than having no planning at all.

At the same time, this step determines the quality of your management – which, in turn, will
determine the success of the project. The more detailed and well-thought the planning is,
the easier it becomes to follow the schedule and prevent too many issues along the process.

As a result, the planning phase is all about researching, deciding and documenting all the
aspects: goals, deliverables, tasks, costs, deadlines.

But don’t forget to set meaningful engineering KPIs and metrics in place to quantify your
projects’ success for the concrete targets you set.

To give you a more specific structure, now’s the time when you’d have to work on:

9
 Software Engineering Prof :Padmini.B

 An approximate timeline and main stages of the development

 Tasks and subtasks for each individual who works on the project
 Ways of communicating with the team, the client, stakeholders
 Time and cost estimates (more accurate when the requirements are set and analyzed)
 Release dates and types of releases
 Documentation of everything (even though you’ll make iterations, keep this intact).

An ideal scenario is to have the software development team working together with the
marketing and the testing team to align business and development goals – but that’s not a
rule. If they’re part of an external team, testers, for example, can cover their part at a later
stage.

The planning stage also describes the specific stages of the project development, work needed
in each stage, and cost estimation.

The timeline should be frequently revisited. Nothing is set in stone when it comes to
software development, since it’s always a complex process to handle, so adaptability is key.

Waydev is trusted by over 1,000 engineering leaders worldwide. Discover how our complete
Git Analytics tool features can also help you to increase velocity and reduce cycle time.

4. Design & Prototyping

The next part of an effective project planning software is conceptual designing. This has
nothing to do with the aesthetics, but with the project architecture and functionality.

As a result, it’s done by software architects and engineers to make sure the flow, structure
and the functionality meet the project requirements. It can include:

 The whole structure and its capabilities

 The functionality of the software solution

10
 Software Engineering Prof :Padmini.B

 Hardware and software components, if needed

 Software tools for future development
 Processes that meet the business needs and goals.

In this stage of the software development life cycle, it’s expected to create either simple, easy
to understand wireframes that show the functions and interactions of the product – or
prototyping, if you need feedback from users on the proposed features.

5. Measuring and Tracking Progress

Before moving on, we have to take a look at this step of the planning process checklist.

You need to set software metrics to track and measure performance and code
quality. Setting these metrics should take place at the beginning of the project development,
to secure a clear and steady workflow with as few roadblocks as possible

Without these measurements to collect and provide valuable data, you cannot manage the
project effectively.

Project analytics, or development analytics, are essential tools that help you accurately
spot and then clear out potential or existing obstacles during the software development life
cycle.

As you track and measure these software metrics, it becomes easier to see work trends, as
well as the level of code quality and deployment readiness, to name a few. Learn what
metrics to track here: Software Metrics Leaders Can Measure to Track the Development
Process.

Our tool provides you with all the relevant developer metrics you need to track and measure
work from start to finish – in real-time.

11
Software Engineering Prof :Padmini.B

You have, for example, the Project Timeline report that shows you the most actionable
metrics in code-based activity. It helps you see what your team is working on over a sprint or
a custom time frame.

Depending on the project requirements, evaluating them will lead you to build better software
faster, to ask for additional resources, or adjust the delivery dates based on objective data.

You get a crystal-clear overview of the Code Review Workflow metrics to learn what’s going
on in the review process to optimize engineer collaboration.

And you also get incredible insights with automated executive reports on Resource
Planning and Project Costs to understand how resources are spent and to help teams ship on
schedule.

Working remotely? Request a demo and get the Agile data-driven approach to software
development no matter where your teams are.

12
Software Engineering Prof :Padmini.B

6. Development & Coding

Once the design step is complete, it’s time to move to implementing them through coding. So
this next one in effective project planning software is one of the hardest, most complex and
time-consuming one: the software development stage.

The software development team is now starting to build the solution according to the scope of
the project, requirements and proposed functionalities previously agreed on. Depending on
the size of the project, it can be a simple and quick process, or a more complex one that
requires various integrations and functionalities.

Either way, the role of the planning work is to make sure you keep potential risks at a
minimum and build a stable, clean and effective software product.

13
 Software Engineering Prof :Padmini.B

7. Testing & Quality Control

Still, the delivery of reliable software is not done without quality testing. You’ll have to
check:

 Compliance with project requirements

 Meeting the budget and time estimates
 Code quality and other relevant software metrics.

That is why this step of the planning process requires you to have these aspects set in place
before starting the actual work.

Oftentimes, development and testing are conducted simultaneously to make sure each
software feature your team is developing is bug-free and ready to go. However, once the
software solution is completely developed, it still needs a full round of testing to make sure
the final product is working as it should and it’s bug-free and useful to end-users.

This is why we have this step separate – it’s also a stage that takes more time to finish.

The testing and quality assurance phase can also be covered by an external team. If that’s the
case, they can provide a separate plan for this stage.

14
 Software Engineering Prof :Padmini.B

8. Deployment to Production

This is the (almost) final stage of every software project development process: deploying the
code into production. It’s the moment when all the hard work your developers put in is finally
launched live to end-users.

Deploying is not necessarily taking place at the same time as the production stage. Software
projects are, again, pretty complex. So you might perform several deployments during the
development and testing stages, before having the final deployment to production.

Sometimes, the process looks like this during the development, testing and production
stages:

 Your team builds, deploys and tests code until it is ready for release;
 That code becomes a release candidate;
 Your team deploys the release candidate for pre-release testing;
 Work on release candidates until one is stable enough as the final one;
 Name that stable release candidate as the release version
 Deploy the release version to production.

9. Support & Maintenance

Even though the planned development work is done, that doesn’t mean the work on the
software is also done. After launching it live, the software usually goes through other stages
of its development.

The post-production stage refers to the support and maintenance of the live software. Almost
all digital projects need some sort of basic maintenance or maybe more advanced updates – at
some point or on a regular basis, hence the name of software development life cycle.
15
 Software Engineering Prof :Padmini.B

Just like customer needs are always evolving, so do the products and services they use.

The goal of this stage is to ensure the scalability and improvement of the initial software
to better serve its users through:

 Basic maintenance of the existing software

 Bug fixing – there will always be bugs to fix, once the people use the live software;
 New (or improved) features and functionalities to be added, depending on the user feedback

One important thing to remember is that the client should have everything about the project
available to them. In your planning process, make sure that:

 The client can have technical assistance post-deployment (usually agreed initially);
 You have complete documentation of the software project from ideation to production;
 There is a documented plan on maintenance, support and documentation practices;
 There’s a clear procedure when it comes to technical debt and code quality control (keeping
developers accountable). Find out more here about measuring developer productivity with the
right performance metrics.

Make sure you have all this data written in the project timeline and list of activities (tasks and
subtasks) so that you’ll know how to prioritize them accordingly.

16
Software Engineering Prof :Padmini.B

Software Development Life Cycle (SDLC)

A software life cycle model (also termed process model) is a pictorial and diagrammatic
representation of the software life cycle. A life cycle model represents all the methods
required to make a software product transit through its life cycle stages. It also captures the
structure in which these methods are to be undertaken.

In other words, a life cycle model maps the various activities performed on a software
product from its inception to retirement. Different life cycle models may plan the necessary
development activities to phases in different ways. Thus, no element which life cycle model
is followed, the essential activities are contained in all life cycle models though the action
may be carried out in distinct orders in different life cycle models. During any life cycle
stage, more than one activity may also be carried out.

Need of SDLC

The development team must determine a suitable life cycle model for a particular plan and
then observe to it.

Without using an exact life cycle model, the development of a software product would not be
in a systematic and disciplined manner. When a team is developing a software product, there
must be a clear understanding among team representative about when and what to do.
Otherwise, it would point to chaos and project failure. This problem can be defined by using
an example. Suppose a software development issue is divided into various parts and the parts
are assigned to the team members. From then on, suppose the team representative is allowed
the freedom to develop the roles assigned to them in whatever way they like. It is possible
that one representative might start writing the code for his part, another might choose to
prepare the test documents first, and some other engineer might begin with the design phase
of the roles assigned to him. This would be one of the perfect methods for project failure.

A software life cycle model describes entry and exit criteria for each phase. A phase can
begin only if its stage-entry criteria have been fulfilled. So without a software life cycle
model, the entry and exit criteria for a stage cannot be recognized. Without software life
cycle models, it becomes tough for software project managers to monitor the progress of the
project.

SDLC Cycle

SDLC Cycle represents the process of developing software. SDLC framework includes the
following steps:

17
Software Engineering Prof :Padmini.B

The stages of SDLC are as follows:

Stage1: Planning and requirement analysis

Requirement Analysis is the most important and necessary stage in SDLC.

The senior members of the team perform it with inputs from all the stakeholders and domain
experts or SMEs in the industry.

Planning for the quality assurance requirements and identifications of the risks associated
with the projects is also done at this stage.

Business analyst and Project organizer set up a meeting with the client to gather all the data
like what the customer wants to build, who will be the end user, what is the objective of the
product. Before creating a product, a core understanding or knowledge of the product is very
necessary.

For Example, A client wants to have an application which concerns money transactions. In
this method, the requirement has to be precise like what kind of operations will be done, how
it will be done, in which currency it will be done, etc.

Once the required function is done, an analysis is complete with auditing the feasibility of the
growth of a product. In case of any ambiguity, a signal is set up for further discussion.

18
Software Engineering Prof :Padmini.B

Once the requirement is understood, the SRS (Software Requirement Specification)

document is created. The developers should thoroughly follow this document and also should
be reviewed by the customer for future reference.

Stage2: Defining Requirements

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

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

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

Stage3: Designing the Software

The next phase is about to bring down all the knowledge of requirements, analysis, and
design of the software project. This phase is the product of the last two, like inputs from the
customer and requirement gathering.

Stage4: Developing the project

In this phase of SDLC, the actual development begins, and the programming is built. The
implementation of design begins concerning writing code. Developers have to follow the
coding guidelines described by their management and programming tools like compilers,
interpreters, debuggers, etc. are used to develop and implement the code.

Stage5: Testing

After the code is generated, it is tested against the requirements to make sure that the
products are solving the needs addressed and gathered during the requirements stage.

During this stage, unit testing, integration testing, system testing, acceptance testing are done.

Stage6: Deployment

Once the software is certified, and no bugs or errors are stated, then it is deployed.

Then based on the assessment, the software may be released as it is or with suggested
enhancement in the object segment.

After the software is deployed, then its maintenance begins.

Stage7: Maintenance

19
Software Engineering Prof :Padmini.B

Once when the client starts using the developed systems, then the real issues come up and
requirements to be solved from time to time.

This procedure where the care is taken for the developed product is known as maintenance.

SDLC Models

Software Development life cycle (SDLC) is a spiritual model used in project management
that defines the stages include in an information system development project, from an initial
feasibility study to the maintenance of the completed application.

There are different software development life cycle models specify and design, which are
followed during the software development phase. These models are also called "Software
Development Process Models." Each process model follows a series of phase unique to its
type to ensure success in the step of software development.

Here, are some important phases of SDLC life cycle:

Waterfall Model

The waterfall is a universally accepted SDLC model. In this method, the whole process of
software development is divided into various phases.

20
Software Engineering Prof :Padmini.B

The waterfall model is a continuous software development model in which development is

seen as flowing steadily downwards (like a waterfall) through the steps of requirements
analysis, design, implementation, testing (validation), integration, and maintenance.

Linear ordering of activities has some significant consequences. First, to identify the end of a
phase and the beginning of the next, some certification techniques have to be employed at the
end of each step. Some verification and validation usually do this mean that will ensure that
the output of the stage is consistent with its input (which is the output of the previous step),
and that the output of the stage is consistent with the overall requirements of the system.

RAD Model

RAD or Rapid Application Development process is an adoption of the waterfall model; it

targets developing software in a short period. The RAD model is based on the concept that a
better system can be developed in lesser time by using focus groups to gather system
requirements.

o Business Modeling
o Data Modeling
o Process Modeling
o Application Generation
o Testing and Turnover

Spiral Model

The spiral model is a risk-driven process model. This SDLC model helps the group to adopt
elements of one or more process models like a waterfall, incremental, waterfall, etc. The
spiral technique is a combination of rapid prototyping and concurrency in design and
development activities.

Each cycle in the spiral begins with the identification of objectives for that cycle, the different
alternatives that are possible for achieving the goals, and the constraints that exist. This is the
first quadrant of the cycle (upper-left quadrant).

The next step in the cycle is to evaluate these different alternatives based on the objectives
and constraints. The focus of evaluation in this step is based on the risk perception for the
project.

The next step is to develop strategies that solve uncertainties and risks. This step may involve
activities such as benchmarking, simulation, and prototyping.

21
Software Engineering Prof :Padmini.B

V-Model

In this type of SDLC model testing and the development, the step is planned in parallel. So,
there are verification phases on the side and the validation phase on the other side. V-Model
joins by Coding phase.

Incremental Model

The incremental model is not a separate model. It is necessarily a series of waterfall cycles.
The requirements are divided into groups at the start of the project. For each group, the SDLC
model is followed to develop software. The SDLC process is repeated, with each release
adding more functionality until all requirements are met. In this method, each cycle act as the
maintenance phase for the previous software release. Modification to the incremental model
allows development cycles to overlap. After that subsequent cycle may begin before the
previous cycle is complete.

Agile Model

Agile methodology is a practice which promotes continues interaction of development and

testing during the SDLC process of any project. In the Agile method, the entire project is
divided into small incremental builds. All of these builds are provided in iterations, and each
iteration lasts from one to three weeks.

Any agile software phase is characterized in a manner that addresses several key assumptions
about the bulk of software projects:

1. It is difficult to think in advance which software requirements will persist and which
will change. It is equally difficult to predict how user priorities will change as the
project proceeds.
2. For many types of software, design and development are interleaved. That is, both
activities should be performed in tandem so that design models are proven as they are
created. It is difficult to think about how much design is necessary before construction
is used to test the configuration.
3. Analysis, design, development, and testing are not as predictable (from a planning
point of view) as we might like.

Iterative Model

It is a particular implementation of a software development life cycle that focuses on an

initial, simplified implementation, which then progressively gains more complexity and a
broader feature set until the final system is complete. In short, iterative development is a way
of breaking down the software development of a large application into smaller pieces.

22
Software Engineering Prof :Padmini.B

Big bang model

Big bang model is focusing on all types of resources in software development and coding,
with no or very little planning. The requirements are understood and implemented when they
come.

This model works best for small projects with smaller size development team which are
working together. It is also useful for academic software development projects. It is an ideal
model where requirements are either unknown or final release date is not given.

Prototype Model

The prototyping model starts with the requirements gathering. The developer and the user
meet and define the purpose of the software, identify the needs, etc.

A 'quick design' is then created. This design focuses on those aspects of the software that
will be visible to the user. It then leads to the development of a prototype. The customer then
checks the prototype, and any modifications or changes that are needed are made to the
prototype.

Looping takes place in this step, and better versions of the prototype are created. These are
continuously shown to the user so that any new changes can be updated in the prototype. This
process continue until the customer is satisfied with the system. Once a user is satisfied, the
prototype is converted to the actual system with all considerations for quality and security.

Waterfall model:

 Winston Royce introduced the Waterfall Model in 1970.This model has five
phases: Requirements analysis and specification, design, implementation, and unit
testing, integration and system testing, and operation and maintenance.

 The steps always follow in this order and do not overlap. The developer must
complete every phase before the next phase begins.

 This model is named "Waterfall Model", because its diagrammatic representation

resembles a cascade of waterfalls.

1. Requirements analysis and specification phase:

 The aim of this phase is to understand the exact requirements of the customer
and to document them properly.

 Both the customer and the software developer work together so as to

document all the functions, performance, and interfacing requirement of the
software.

23
Software Engineering Prof :Padmini.B

 It describes the "what" of the system to be produced and not "how."In this
phase, a large document called Software Requirement Specification
(SRS) document is created which contained a detailed description of what the
system will do in the common language.

2. Design Phase: This phase aims 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 a Software Design Document (SDD).

3. Implementation and unit testing: During this phase, design is implemented. If the SDD
is complete, the implementation or coding phase proceeds smoothly, because all the
information needed by software developers is contained in the SDD.

During testing, the code is thoroughly examined and modified. Small modules are tested in
isolation initially. After that these modules are tested by writing some overhead code to check
the interaction between these modules and the flow of intermediate output.

4. 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. The 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.

5. Operation and maintenance phase: Maintenance is the task performed by every user
once the software has been delivered to the customer, installed, and operational.

When to use SDLC Waterfall Model?

Some Circumstances where the use of the Waterfall model is most suited are:

o When the requirements are constant and not changed regularly.

o A project is short

24
Software Engineering Prof :Padmini.B

o The situation is calm

o Where the tools and technology used is consistent and is not changing
o When resources are well prepared and are available to use.

Advantages of Waterfall model

o This model is simple to implement also the number of resources that are required for
it is minimal.
o The requirements are simple and explicitly declared; they remain unchanged during
the entire project development.
o The start and end points for each phase is fixed, which makes it easy to cover
progress.
o The release date for the complete product, as well as its final cost, can be determined
before development.
o It gives easy to control and clarity for the customer due to a strict reporting system.

Disadvantages of Waterfall model

o In this model, the risk factor is higher, so this model is not suitable for more
significant and complex projects.
o This model cannot accept the changes in requirements during development.
o It becomes tough to go back to the phase. For example, if the application has now
shifted to the coding phase, and there is a change in requirement, It becomes tough to
go back and change it.
o Since the testing done at a later stage, it does not allow identifying the challenges and
risks in the earlier phase, so the risk reduction strategy is difficult to prepare.

RAD (Rapid Application Development) Model

RAD is a linear sequential software development process model that emphasizes a concise
development cycle using an element based construction approach. If the requirements are
well understood and described, and the project scope is a constraint, the RAD process enables
a development team to create a fully functional system within a concise time period.

RAD (Rapid Application Development) is a concept that products can be developed faster
and of higher quality through:

o Gathering requirements using workshops or focus groups

o Prototyping and early, reiterative user testing of designs
o The re-use of software components
o A rigidly paced schedule that refers design improvements to the next product version
o Less formality in reviews and other team communication

25
Software Engineering Prof :Padmini.B

The various phases of RAD are as follows:

1.Business Modelling: The information flow among business functions is defined by

answering questions like what data drives the business process, what data is generated, who
generates it, where does the information go, who process it and so on.

2. Data Modelling: The data 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.

3. Process Modelling: The information object defined in the data modeling phase are
transformed to achieve the data flow necessary to implement a business function. Processing
descriptions are created for adding, modifying, deleting, or retrieving a data object.

4. Application Generation: Automated tools are used to facilitate construction of the

software; even they use the 4th GL techniques.

5. Testing & Turnover: Many of the programming components have already been tested
since RAD emphasis reuse. This reduces the overall testing time. But the new part must be
tested, and all interfaces must be fully exercised.

When to use RAD Model?

o When the system should need to create the project that modularizes in a short span
time (2-3 months).
o When the requirements are well-known.
o When the technical risk is limited.
o When there's a necessity to make a system, which modularized in 2-3 months of
period.

26
Software Engineering Prof :Padmini.B

o It should be used only if the budget allows the use of automatic code generating tools.

Advantage of RAD Model

o This model is flexible for change.

o In this model, changes are adoptable.
o Each phase in RAD brings highest priority functionality to the customer.
o It reduced development time.
o It increases the reusability of features.

Disadvantage of RAD Model

o It required highly skilled designers.

o All application is not compatible with RAD.
o For smaller projects, we cannot use the RAD model.
o On the high technical risk, it's not suitable.
o Required user involvement.

Spiral Model

The spiral model, initially proposed by Boehm, is an evolutionary software process model
that couples the iterative feature of prototyping with the controlled and systematic aspects of
the linear sequential model. It implements the potential for rapid development of new
versions of the software. Using the spiral model, the software is developed in a series of
incremental releases. During the early iterations, the additional release may be a paper model
or prototype. During later iterations, more and more complete versions of the engineered
system are produced.

The Spiral Model is shown in fig:

27
Software Engineering Prof :Padmini.B

Each cycle in the spiral is divided into four parts:

Objective setting: Each cycle in the spiral starts with the identification of purpose for that
cycle, the various alternatives that are possible for achieving the targets, and the constraints
that exists.

Risk Assessment and reduction: The next phase in the cycle is to calculate these various
alternatives based on the goals and constraints. The focus of evaluation in this stage is located
on the risk perception for the project.

Development and validation: The next phase is to develop strategies that resolve
uncertainties and risks. This process may include activities such as benchmarking, simulation,
and prototyping.

Planning: Finally, the next step is planned. The project is reviewed, and a choice made
whether to continue with a further period of the spiral. If it is determined to keep, plans are
drawn up for the next step of the project.

The development phase depends on the remaining risks. For example, if performance or user-
interface risks are treated more essential than the program development risks, the next phase
may be an evolutionary development that includes developing a more detailed prototype for
solving the risks.

The risk-driven feature of the spiral model allows it to accommodate any mixture of a
specification-oriented, prototype-oriented, simulation-oriented, or another type of approach.
An essential element of the model is that each period of the spiral is completed by a review
that includes all the products developed during that cycle, including plans for the next cycle.
The spiral model works for development as well as enhancement projects.

28
Software Engineering Prof :Padmini.B

When to use Spiral Model?

o When deliverance is required to be frequent.

o When the project is large
o When requirements are unclear and complex
o When changes may require at any time
o Large and high budget projects

Advantages

o High amount of risk analysis

o Useful for large and mission-critical projects.

Disadvantages

o Can be a costly model to use.

o Risk analysis needed highly particular expertise
o Doesn't work well for smaller projects.

Agile Model

The meaning of Agile is swift or versatile."Agile process model" refers to a software

development approach based on iterative development. Agile methods break tasks into
smaller iterations, or parts do not directly involve long term planning. The project scope and
requirements are laid down at the beginning of the development process. Plans regarding the
number of iterations, the duration and the scope of each iteration are clearly defined in
advance.

Each iteration is considered as a short time "frame" in the Agile process model, which
typically lasts from one to four weeks. The division of the entire project into smaller parts
helps to minimize the project risk and to reduce the overall project delivery time
requirements. Each iteration involves a team working through a full software development
life cycle including planning, requirements analysis, design, coding, and testing before a
working product is demonstrated to the client.

29
Software Engineering Prof :Padmini.B

Phases of Agile Model:

Following are the phases in the Agile model are as follows:

1. Requirements gathering
2. Design the requirements
3. Construction/ iteration
4. Testing/ Quality assurance
5. Deployment
6. Feedback

1. Requirements gathering: In this phase, you must define the requirements. You should
explain business opportunities and plan the time and effort needed to build the project. Based
on this information, you can evaluate technical and economic feasibility.

2. Design the requirements: When you have identified the project, work with stakeholders
to define requirements. You can use the user flow diagram or the high-level UML diagram to
show the work of new features and show how it will apply to your existing system.

3. Construction/ iteration: When the team defines the requirements, the work begins.
Designers and developers start working on their project, which aims to deploy a working
product. The product will undergo various stages of improvement, so it includes simple,
minimal functionality.

30
Software Engineering Prof :Padmini.B

4. Testing: In this phase, the Quality Assurance team examines the product's performance
and looks for the bug.

5. Deployment: In this phase, the team issues a product for the user's work environment.

6. Feedback: After releasing the product, the last step is feedback. In this, the team receives
feedback about the product and works through the feedback.

Agile Testing Methods:

o Scrum
o Crystal
o Dynamic Software Development Method(DSDM)
o Feature Driven Development(FDD)
o Lean Software Development
o eXtreme Programming(XP)

Scrum

SCRUM is an agile development process focused primarily on ways to manage tasks in team-
based development conditions.

There are three roles in it, and their responsibilities are:

o Scrum Master: The scrum can set up the master team, arrange the meeting and
remove obstacles for the process
o Product owner: The product owner makes the product backlog, prioritizes the delay
and is responsible for the distribution of functionality on each repetition.
o Scrum Team: The team manages its work and organizes the work to complete the
sprint or cycle.

eXtreme Programming(XP)

This type of methodology is used when customers are constantly changing demands or
requirements, or when they are not sure about the system's performance.

Crystal:

There are three concepts of this method-

1. Chartering: Multi activities are involved in this phase such as making a development
team, performing feasibility analysis, developing plans, etc.
2. Cyclic delivery: under this, two more cycles consist, these are:

31
Software Engineering Prof :Padmini.B

A. Team updates the release plan.

B. Integrated product delivers to the users.
3. Wrap up: According to the user environment, this phase performs deployment, post-
deployment.

Dynamic Software Development Method(DSDM):

DSDM is a rapid application development strategy for software development and gives an
agile project distribution structure. The essential features of DSDM are that users must be
actively connected, and teams have been given the right to make decisions. The techniques
used in DSDM are:

1. Time Boxing
2. MoSCoW Rules
3. Prototyping

The DSDM project contains seven stages:

1. Pre-project
2. Feasibility Study
3. Business Study
4. Functional Model Iteration
5. Design and build Iteration
6. Implementation
7. Post-project

Feature Driven Development(FDD):

This method focuses on "Designing and Building" features. In contrast to other smart
methods, FDD describes the small steps of the work that should be obtained separately per
function.

Lean Software Development:

Lean software development methodology follows the principle "just in time production." The
lean method indicates the increasing speed of software development and reducing costs. Lean
development can be summarized in seven phases.

1. Eliminating Waste
2. Amplifying learning
3. Defer commitment (deciding as late as possible)
4. Early delivery

32
Software Engineering Prof :Padmini.B

5. Empowering the team

6. Building Integrity
7. Optimize the whole

When to use the Agile Model?

o When frequent changes are required.

o When a highly qualified and experienced team is available.
o When a customer is ready to have a meeting with a software team all the time.
o When project size is small.

Advantage(Pros) of Agile Method:

1. Frequent Delivery
2. Face-to-Face Communication with clients.
3. Efficient design and fulfils the business requirement.
4. Anytime changes are acceptable.
5. It reduces total development time.

Disadvantages(Cons) of Agile Model:

1. Due to the shortage of formal documents, it creates confusion and crucial decisions
taken throughout various phases can be misinterpreted at any time by different team
members.
2. Due to the lack of proper documentation, once the project completes and the
developers allotted to another project, maintenance of the finished project can become
a difficulty.

Iterative Model

In this Model, you can start with some of the software specifications and develop the first
version of the software. After the first version if there is a need to change the software, then a
new version of the software is created with a new iteration. Every release of the Iterative
Model finishes in an exact and fixed period that is called iteration.

The Iterative Model allows the accessing earlier phases, in which the variations made
respectively. The final output of the project renewed at the end of the Software Development
Life Cycle (SDLC) process.

33
Software Engineering Prof :Padmini.B

The various phases of Iterative model are as follows:

1. Requirement gathering & analysis: In this phase, requirements are gathered from
customers and check by an analyst whether requirements will fulfil or not. Analyst checks
that need will achieve within budget or not. After all of this, the software team skips to the
next phase.

2. Design: In the design phase, team design the software by the different diagrams like Data
Flow diagram, activity diagram, class diagram, state transition diagram, etc.

3. Implementation: In the implementation, requirements are written in the coding language

and transformed into computer programmes which are called Software.

4. Testing: After completing the coding phase, software testing starts using different test
methods. There are many test methods, but the most common are white box, black box, and
grey box test methods.

5. Deployment: After completing all the phases, software is deployed to its work
environment.

6. Review: In this phase, after the product deployment, review phase is performed to check
the behaviour and validity of the developed product. And if there are any error found then the
process starts again from the requirement gathering.

7. Maintenance: In the maintenance phase, after deployment of the software in the working
environment there may be some bugs, some errors or new updates are required. Maintenance
involves debugging and new addition options.

34
Software Engineering Prof :Padmini.B

When to use the Iterative Model?

1. When requirements are defined clearly and easy to understand.

2. When the software application is large.
3. When there is a requirement of changes in future.

Advantage(Pros) of Iterative Model:

1. Testing and debugging during smaller iteration is easy.

2. A Parallel development can plan.
3. It is easily acceptable to ever-changing needs of the project.
4. Risks are identified and resolved during iteration.
5. Limited time spent on documentation and extra time on designing.

Disadvantage(Cons) of Iterative Model:

1. It is not suitable for smaller projects.

2. More Resources may be required.
3. Design can be changed again and again because of imperfect requirements.
4. Requirement changes can cause over budget.
5. Project completion date not confirmed because of changing requirements.

35
Software Engineering Prof :Padmini.B

36