Unit I Overview of Software Engineering & Its Methodologies

 Defining Software Engineering

 Software Engineering Principles
 Software Engineering Ethics,
 Software Process
 Project, Product and People
 Overview of Software development lifecycle methodologies
 Waterfall, Agile, Lean, Iterative, Spiral, DevOps.

Engineering is the creative application of science, mathematical methods, and empirical evidence
to the innovation, design, construction, and maintenance of structures, machines, materials,
devices, systems, processes, and organizations.

Software is a program or set of programs containing instructions that provide desired

functionality. And Engineering is the process of designing and building something that serves a
particular purpose and finds a cost-effective solution to problems.

Software Engineering is a systematic, disciplined, quantifiable study and approach to the

design, development, operation, and maintenance of a software system.
Software Development: In this process, designing, programming, documenting, testing, and
bug fixing is done.

Components of Software:
There are three components of the software: These are: Program, Documentation, and
Operating Procedures.

1. Program –
A computer program is a list of instructions that tell a computer what to do.

2. Documentation –
Source information about the product contained in design documents, detailed code
comments, etc.

3. Operating Procedures –
Set of step-by-step instructions compiled by an organization to help workers carry out
complex routine operations.
Objectives of Software Engineering:

1. Maintainability –
It should be feasible for the software to evolve to meet changing requirements.
2. Efficiency –
The software should not make wasteful use of computing devices such as memory,
processor cycles, etc.
3. Correctness –
A software product is correct if the different requirements as specified in the SRS
document have been correctly implemented.
4. Reusability –
A software product has good reusability if the different modules of the product can easily
be reused to develop new products.
5. Testability –
Here software facilitates both the establishment of test criteria and the evaluation of the
software with respect to those criteria.
6. Reliability –
It is an attribute of software quality. The extent to which a program can be expected to
perform its desired function, over an arbitrary time period.
7. Portability –
In this case, the software can be transferred from one computer system or environment to
another.
8. Adaptability –
In this case, the software allows differing system constraints and the user needs to be
satisfied by making changes to the software.
9. Interoperability – Capability of 2 or more functional units to process data cooperatively.

Software Engineering Principles

Some basic principles of good software engineering are –

1. One of the basic software Engineering principles is Better Requirement analysis which gives
a clear vision of the project. At last, a good understanding of user requirements provides
value to its users by delivering a good software product that meets users’ requirements.

2. All designs and implementations should be as simple as possible mean the KISS (Keep it
Simple, Stupid) principle should be followed. It makes code so simple as a result
debugging and further maintenance become simple.

3. Maintaining the vision of the project is the most important thing throughout complete
development process for the success of a software project. A clear vision of the project
leads to the development of the project in the right way .

4. Software projects include a number of functionalities, all functionalities should be

developed in a modular approach so that development will be faster and easier. This
 modularity makes functions or system components independent.

5. Another specialization of the principle of separation of concerns is Abstraction for

suppressing complex things and delivering simplicity to the customer/user means it gives
what the actual user needs and hides unnecessary things.

6. Think then Act is a must-required principle for software engineering means before starting
developing functionality first it requires to think about application architecture, as good
planning on the flow of project development produces better results.

7. Principle of Consistency is important in coding style and designing GUI (Graphical User
Interface) as consistent coding style gives an easier reading of code and consistency in GUI
makes user learning easier in dealing with interface and in using the software.

8. Never waste time if anything is required and that already exists at that time take the help of
Open source and fix it in your own way as per requirement.

9. Performing continuous validation helps in checking software system meets requirement

specifications and fulfills its intended purpose which helps in better software quality control.

Software Engineering Ethics

1. Confidentiality :

The main principle of confidentiality is to maintain privacy. It is basically defined as

a state of keeping something private or secret. Reviewer also has main responsibility
to keep documents private and secret that is under review. To keep private means
not to share or discuss with anyone outside review process unless it is necessary and
approved by editor.

2. Competence :

Competence is basically described as quality or state of having sufficient knowledge,

required skill, qualification, strength. For review process, reviewers should only
accept review if he/she has knowledge, expert, and required skill for reviewing
particular material.
If reviewer is not expert regarding material then there is possibility of substantial
deficiencies or rejection of material. Therefore, reviewer should not accept review in
such cases.
3. Timeliness and responsiveness :

Timeliness simply means quality of doing something at a favorable or best time

whereas responsiveness simply means quality of reacting quickly and positively.
 Reviewers are also responsible for reviewing material quickly in time requested and
submit it in a given period of time.
Reviewer needs to put every possible effort to complete review in a positive manner
within time requested. If reviewer cannot complete review in time requested, then
he/she should not accept review in such cases.
4. Impartiality and Integrity :

Impartiality simply means fairness in decisions, feedback. Reviewer also has

responsibility to provide impartial i.e., unbiased and constructive feedback in a timely
manner. They are also responsible ensure that feedback has adequate i.e. acceptable
detail. They should not take advantage of material through communication of peer
review.

5. Intellectual Property :
Intellectual property management software assists in the tracking of trademarks, copyrights,
patents, and other intellectual property. Law firms and corporations utilize these tools to
manage databases of trademarks, automate forms and correspondence for new and ongoing
intellectual property ownership, and track possible violations of legal rights for subsequent
prosecution.

6. For law firms who manage designers, artists, inventors, and companies with patented products
or services, intellectual property management software helps centralize up-to-date client
information,

Software Process
For properly building a product, there’s a very important concept that we all should know
in software project planning while developing a product. There are 4 critical components
in software project planning which are known as the 4P’s namely:
 Product
 Process
 People
 Project
These components play a very important role in your project that can help your team meet
its goals and objective. Now, let’s dive into each of them a little in detail to get a better
understanding:
 People
The most important component of a product and its successful implementation is
human resources. In building a proper product, a well-managed team with clear-cut
roles defined for each person/team will lead to the success of the product. We need to
have a good team in order to save our time, cost, and effort. Some assigned roles in
software project planning are project manager, team leaders, stakeholders,
analysts, and other IT professionals. Managing people successfully is a tricky
process which a good project manager can do.
 Product
As the name inferred, this is the deliverable or the result of the project. The project
manager should clearly define the product scope to ensure a successful result, control
the team members, as well technical hurdles that he or she may encounter during the
building of a product. The product can consist of both tangible and intangible such as
shifting the company to a new place or getting a new software in a company.

 Process
In every planning, a clearly defined process is the key to the success of any product.
It regulates how the team will go about its development in the respective time period.
The Process has several steps involved like, documentation phase, implementation
phase, deployment phase, and interaction phase.
 Project
The last and final P in software project planning is Project. In this phase, the project
manager plays a critical role. They are responsible to guide the team members to
achieve the project’s target and objectives, helping & assisting them with issues,
checking on cost and budget, and making sure that the project stays on track with the
given deadlines.

Agile Methodologies

Agile is a time-bound, iterative approach to software delivery that builds software

incrementally from the start of the project, instead of trying to deliver all at once.
Why Agile?

Technology in this current era is progressing faster than ever, enforcing the global
software companies to work in a fast-paced changing environment. Because these
businesses are operating in an ever-changing environment, it is impossible to gather a
complete and exhaustive set of software requirements. Without these requirements, it
becomes practically hard for any conventional software model to work.

Let’s now read about the on which the Agile has laid its foundation:

Principles:

1. Highest priority is to satisfy the customer through early and continuous delivery of
valuable software.
2. It welcomes changing requirements, even late in development.
3. Deliver working software frequently, from a couple of weeks to a couple of months,
with a preference to the shortest timescale.
4. Build projects around motivated individuals. Give them the environment and the
support they need, and trust them to get the job done.
5. Working software is the primary measure of progress.
6. Simplicity the art of maximizing the amount of work not done is essential.
7. The most efficient and effective method of conveying information to and within a
development team is face-to-face conversation.
Advantages:
 Deployment of software is quicker and thus helps in increasing the trust of the
customer.
 Can better adapt to rapidly changing requirements and respond faster.
 Helps in getting immediate feedback which can be used to improve the software in
the next increment.
 People – Not Process. People and interactions are given a higher priority rather than
process and tools.
 Continuous attention to technical excellence and good design.
Disadvantages:
 In case of large software projects, it is difficult to assess the effort required at the
initial stages of the software development life cycle.
 The Agile Development is more code focused and produces less documentation.
 Agile development is heavily depended on the inputs of the customer. If the
customer has ambiguity in his vision of the final outcome, it is highly likely for the
project to get off track.
 Face to Face communication is harder in large-scale organizations.

Six methods are identified as agile development methods they are following
 Crystal methodologies
 Dynamic software development method
 Feature-driven development
 Lean software development
 Scrum
 Extreme programming

 Crystal methodologies

The crystal method is an agile framework that is considered a lightweight or agile

methodology that focuses on individuals and their interactions. He decided not to focus
on step-by-step developmental strategies, but to develop team collaboration and
communication.
Properties of Crystal Agile Framework :
1. Frequent Delivery- It allows you regularly deliver the products and test code to real
users. Without this, you might build a product that nobody needs.
2. Reflective Improvement- No matter how good you have done or how bad you have
done. Since there are always areas where the product can be improved, so the teams
can implement to improve their future practices.

3. Osmotic Communication- Alistair stated that having the teams in the same physical
phase is very much important as it allows information to flow in between members of
a team as in osmosis.

4. Personal Safety- There are no bad suggestions in a crystal team, team members
should feel safe to discuss ideas openly without any fear.

5. Focus- Each member of the team knows exactly what to do, which enables them to
focus their attention. This boosts team interaction and works towards the same goal.

6. Easy access to expert users- It enhances team communication with users and gets
regular feedback from real users.

7. Technical tooling- It contains very specific technical tools which to be used by the
software development team during testing, management, and configuration. These
tools make it enable the team to identify any error within less time.

Dynamic Systems Development Method (DSDM)

The Dynamic Systems Development technique (DSDM) is an associate degree agile

code development approach that provides a framework for building and maintaining
systems. The DSDM philosophy is borrowed from a modified version of the sociologist
principle—80 % of An application is often delivered in twenty percent of the time it’d
desire deliver the entire (100 percent) application.
1. Feasibility Study:

It establishes the essential business necessities and constraints related to the applying
to be designed then assesses whether or not the application could be a viable candidate
for the DSDM method.
2. Business Study:

It establishes the use and knowledge necessities that may permit the applying to
supply business value; additionally, it is the essential application design and identifies
the maintainability necessities for the applying.

3. Functional Model Iteration:

It produces a collection of progressive prototypes that demonstrate practicality for the

client. (Note: All DSDM prototypes are supposed to evolve into the deliverable
application.) The intent throughout this unvarying cycle is to collect further
necessities by eliciting feedback from users as they exercise the paradigm.
4. Design and Build Iteration:
 It revisits prototypes designed throughout useful model iteration to make sure that
everyone has been designed during a manner that may alter it to supply operational
business price for finish users. In some cases, useful model iteration and style and
build iteration occur at the same time.

5. Implementation:

It places the newest code increment (an “operationalized” prototype) into the
operational surroundings. It ought to be noted that:
 (a) the increment might not 100% complete or,
 (b) changes are also requested because the increment is placed into place. In either
case, DSDM development work continues by returning to the useful model
iteration activity.

Feature-Driven Development

FDD stands for Feature-Driven Development. It is an agile iterative and incremental

model that focuses on progressing the features of the developing software. The main
motive os feature-driven development is to provide timely updated and working software
to the client. In FDD, reporting and progress tracking is necessary at all levels.
FDD Lifecycle
 Build overall model
 Build feature list
 Plan by feature
 Design by feature
 Build by feature
Characteristics of FDD

 Short iterative: FDD lifecycle works in simple and short iterations to efficiently finish the
work on time and gives good pace for large projects.
 Customer focused: This agile practice is totally based on inspection of each feature by client
and then pushed to main build code.
 Structured and feature focused: Initial activities in lifecycle builds the domain model and
features list in the beginning of timeline and more than 70% of efforts are given to last 2
activities.
 Frequent releases: Feature-driven development provides continuous releases of features in
the software and retaining continuous success of the project.

Advantages of FDD

 Reporting at all levels leads to easier progress tracking.

 FDD provides continuous success for larger size of teams and projects.
 Reduction in risks is observed as whole model and design is built in smaller segments.
 FDD provides greater accuracy in cost estimation of the project due to feature
segmentation.

Disadvantages of FDD

 This agile practice is not good for smaller projects.

 There is high dependency on lead programmers, designers and mentors.
 There is lack of documentation which can create an issue afterwards.

Lean Software Development (LSD)

Lean Software Development (LSD) is an agile framework that is used to streamline &
optimize the software development process. It may also be referred to as Minimum Viable
Product (MVP) strategy as these ways of thinking are very much alike since both intend
to speed up development by focusing on new deliverables.

Key Principles of Lean Software Development:

There are 7 established lean principles that come with a set of tactics, practices, and
processes that builds more efficient software products:
1. Eliminating the waste
2. Fast Delivery
3. Amplify Learning
4. Builds Quality
5. Respect Teamwork
6. Delay the commitment
7. Optimizing the whole system
The below figure illustrates the principles of LSD :

LEAN SOFTWARE DEVELOPMENT (LSD) PRINCIPLE

Eliminating the Waste: To identify and eliminate wastes e.g. unnecessary code, delay
in processes, inefficient communication, the issue with quality, data duplication, more
tasks in the log than completed, etc. regular meetings are held by Project Managers.
Which allows team members to point out faults and suggest changes in the next turn.

Fast Delivery: Previously long time planning used to be the key success in business, but
in the passage of time it is found that engineers spend too much time on building complex
systems with unwanted features. So they came up with an MVP strategy which resulted
in the building products quickly that included a little functionality and launch the product
to market and see the reaction. Such an approach allows them to enhance the product on
the basis of customer feedback.

Amplify Learning: Learning is improved through ample code reviewing, meeting that
is cross-team applicable. It is also ensured that particular knowledge isn’t accumulated
by one engineer who’s writing a particular piece of code so paired programming is used.

Builds Quality: LSD is all about prevent waste, keeping an eye on not sacrificing quality.
Developers often apply test-driven programming to examine the code before it is written.
The quality can also be gained to get constant feedback from team members and project
managers.

Respect Teamwork: LSD focuses on empowering team members, rather than controlling
them. Setting up a collaborative atmosphere, keep perfect balance when there are short
deadlines and immense workload. This method becomes very much important when new
members join a well-established team.

Delay the Commitment: In traditional project management it often happens when you
make your application and it turns out to be completely unfit for the market. LSD method
recognizes this threat and makes room for improvement by postponing irreversible
decisions until all experiment is done. This methodology always constructs software as
flexible, so the new knowledge is available and engineers can make improvements.

SCRUM
Scrum is the type of Agile framework. It is a framework within which people can
address complex adaptive problem while productivity and creativity of delivering product
is at highest possible values. Scrum uses Iterative process.

Silent features of Scrum are:

 Scrum is light-weighted framework
 Scrum emphasizes self-organization
 Scrum is simple to understand
 Scrum framework help the team to work together

Lifecycle of Scrum:

Sprint:
A Sprint is a time-box of one month or less. A new Sprint starts immediately after the
completion of the previous Sprint.

Release:
When the product is completed then it goes to the Release stage.

Sprint Review:
If the product still have some non-achievable features then it will be checked in this
stage and then the product is passed to the Sprint Retrospective stage.

Sprint Retrospective:
In this stage quality or status of the product is checked.

Product Backlog:
According to the prioritize features the product is organized.
Sprint Backlog:
Sprint Backlog is divided into two parts Product assigned features to sprint and Sprint
planning meeting.
Advantage of using Scrum framework:
 Scrum framework is fast moving and money efficient.
 Scrum framework works by dividing the large product into small sub-products. It’s
like a divide and conquer strategy
 In Scrum customer satisfaction is very important.
 Scrum is adaptive in nature because it have short sprint.
 As Scrum framework rely on constant feedback therefore the quality of product
increases in less amount of time

Disadvantage of using Scrum framework:

 Scrum framework do not allow changes into their sprint.
 Scrum framework is not fully described model. If you wanna adopt it you need to fill
in the framework with your own details like Extreme Programming (XP), Kanban,
and DSDM.
 It can be difficult for the Scrum to plan, structure and organize a project that lacks a
clear definition.
 The daily Scrum meetings and frequent reviews require substantial resources.

Extreme Programming (XP)

Extreme programming (XP) is one of the most important software development
frameworks of Agile models. It is used to improve software quality and responsiveness
to customer requirements. The extreme programming model recommends taking the best
practices that have worked well in the past in program development projects to extreme
levels. Good practices need to be practiced in extreme programming: Some of the
good practices that have been recognized in the extreme programming model and
suggested to maximize their use are given below:

 Code Review: Code review detects and corrects errors efficiently. It suggests pair
programming as coding and reviewing of written code carried out by a pair of
programmers who switch their works between them every hour.

 Testing: Testing code helps to remove errors and improves its reliability. XP suggests
test-driven development (TDD) to continually write and execute test cases. In the
TDD approach test cases are written even before any code is written.
 Incremental development: Incremental development is very good because customer
feedback is gained and based on this development team comes up with new
increments every few days after each iteration.

 Simplicity: Simplicity makes it easier to develop good quality code as well as to test
and debug it.

 Design: Good quality design is important to develop good quality software. So,
everybody should design daily.

 Integration testing: It helps to identify bugs at the interfaces of different

functionalities. Extreme programming suggests that the developers should achieve
continuous integration by building and performing integration testing several times a
day.

Some of the basic activities that are followed during software development by using the
XP model are given below:
 Coding: The concept of coding which is used in the XP model is slightly different
from traditional coding. Here, the coding activity includes drawing diagrams
(modeling) that will be transformed into code, scripting a web-based system, and
choosing among several alternative solutions.

 Testing: XP model gives high importance to testing and considers it to be the primary
factor to develop fault-free software.

 Listening: The developers need to carefully listen to the customers if they have to
develop good quality software. Sometimes programmers may not have the depth
knowledge of the system to be developed. So, the programmers should understand
properly the functionality of the system and they have to listen to the customers.

 Designing: Without a proper design, a system implementation becomes too complex

and very difficult to understand the solution, thus making maintenance expensive. A
good design results elimination of complex dependencies within a system. So,
effective use of suitable design is emphasized.

 Feedback: One of the most important aspects of the XP model is to gain feedback to
understand the exact customer needs. Frequent contact with the customer makes the
development effective.
 Simplicity: The main principle of the XP model is to develop a simple system that
will work efficiently in the present time, rather than trying to build something that
would take time and may never be used. It focuses on some specific features that are
immediately needed, rather than engaging time and effort on speculations of future
requirements.
Applications of Extreme Programming (XP): Some of the projects that are suitable to
develop using the XP model are given below:

 Small projects: XP model is very useful in small projects consisting of small teams
as the face-to-face meeting is easier to achieve.
 Projects involving new technology or Research projects: This type of project face
changing requirements rapidly and technical problems. So XP model is used to
complete this type of project.

Waterfall model

The classical waterfall model is the basic software development life cycle model. It is
very simple but idealistic. Earlier this model was very popular but nowadays it is not
used. But it is very important because all the other software development life cycle
models are based on the classical waterfall model.

The classical waterfall model divides the life cycle into a set of phases. This model
considers that one phase can be started after the completion of the previous phase. That
is the output of one phase will be the input to the next phase.
Thus the development process can be considered as a sequential flow in the waterfall.
Here the phases do not overlap with each other. The different sequential phases of the
classical waterfall model are shown in the below figure:
Let us now learn about each of these phases in brief detail:

1. Feasibility Study: The main goal of this phase is to determine whether it would be
financially and technically feasible to develop the software.
The feasibility study involves understanding the problem and then determining the
various possible strategies to solve the problem. These different identified solutions
are analyzed based on their benefits and drawbacks, The best solution is chosen and
all the other phases are carried out as per this solution strategy.

2. Requirements analysis and specification: The aim of the requirement analysis and
specification phase is to understand the exact requirements of the customer and
document them properly. This phase consists of two different activities.

 Requirement gathering and analysis: Firstly all the requirements regarding the
software are gathered from the customer and then the gathered requirements are
analyzed. The goal of the analysis part is to remove incompleteness (an incomplete
requirement is one in which some parts of the actual requirements have been
omitted) and inconsistencies (an inconsistent requirement is one in which some
part of the requirement contradicts some other part).
  Requirement specification: These analyzed requirements are documented in a
software requirement specification (SRS) document. SRS document serves as a
contract between the development team and customers. Any future dispute
between the customers and the developers can be settled by examining the SRS
document.

3. Design: The goal of this phase is to convert the requirements acquired in the SRS into
a format that can be coded in a programming language. It includes high-level and
detailed design as well as the overall software architecture. A Software Design
Document is used to document all of this effort (SDD)

4. Coding and Unit testing: In the coding phase software design is translated into
source code using any suitable programming language. Thus each designed module is
coded. The aim of the unit testing phase is to check whether each module is working
properly or not.

5. Integration and System testing: Integration of different modules are undertaken

soon after they have been coded and unit tested. Integration of various modules is
carried out incrementally over a number of steps. During each integration step,
previously planned modules are added to the partially integrated system and the
resultant system is tested. Finally, after all the modules have been successfully
integrated and tested, the full working system is obtained and system testing is carried
out on this.
System testing consists of three different kinds of testing activities as described
below
 Alpha testing: Alpha testing is the system testing performed by the development
team.
 Beta testing: Beta testing is the system testing performed by a friendly set of
customers.
 Acceptance testing: After the software has been delivered, the customer
performed acceptance testing to determine whether to accept the delivered
software or reject it.

6. Maintenance: Maintenance is the most important phase of a software life cycle. The
effort spent on maintenance is 60% of the total effort spent to develop a full software.
There are basically three types of maintenance :

 Corrective Maintenance: This type of maintenance is carried out to correct errors

that were not discovered during the product development phase.
 Perfective Maintenance: This type of maintenance is carried out to enhance the
functionalities of the system based on the customer’s request.
  Adaptive Maintenance: Adaptive maintenance is usually required for porting the
software to work in a new environment such as working on a new computer
platform or with a new operating system.

Advantages of Classical Waterfall Model

The classical waterfall model is an idealistic model for software development. It is very
simple, so it can be considered the basis for other software development life cycle models.
Below are some of the major advantages of this SDLC model:

 This model is very simple and is easy to understand.

 Phases in this model are processed one at a time.
 Each stage in the model is clearly defined.
 This model has very clear and well-understood milestones.
 Process, actions and results are very well documented.
 Reinforces good habits: define-before- design,
design-before-code.
 This model works well for smaller projects and projects where requirements are
well
understood.

Drawbacks of Classical Waterfall Model

The classical waterfall model suffers from various shortcomings, basically, we can’t use
it in real projects, but we use other software development lifecycle models which are
based on the classical waterfall model. Below are some major drawbacks of this model:

 No feedback path: In the classical waterfall model evolution of software from one
phase to another phase is like a waterfall. It assumes that no error is ever committed
by developers during any phase. Therefore, it does not incorporate any mechanism
for error correction.

 Difficult to accommodate change requests: This model assumes that all the
customer requirements can be completely and correctly defined at the beginning of
the project, but actually customers’ requirements keep on changing with time. It is
difficult to accommodate any change requests after the requirements specification
phase is complete.

 No overlapping of phases: This model recommends that a new phase can start only
after the completion of the previous phase. But in real projects, this can’t be
maintained. To increase efficiency and reduce cost, phases may overlap.
 Iterative Model - Design
Iterative process starts with a simple implementation of a subset of the software
requirements and iteratively enhances the evolving versions until the full system is
implemented. At each iteration, design modifications are made and new functional
capabilities are added. The basic idea behind this method is to develop a system
through repeated cycles (iterative) and in smaller portions at a time (incremental).
The following illustration is a representation of the Iterative and Incremental model −

 In Iterative model, the large application of software development is divided into smaller chunks
and smaller parts of software which can be reviewed to recognize further requirements are
implemented. This process is repeated to generate a new version of the software in each cycle of
a model.
 With every iteration, development module goes through the phases i.e requirement, design,
implementation and testing. These phases are repeated in iterative model in a sequence.

1) Requirement Phase
In this phase, the requirements for the software are assembled and analyzed. Generates a
complete and final specification of requirements.

2) Design Phase
In this phase, a software solution meets the designed requirements which can be a new design or
an extension of an earlier design.

3) Implementation and test phase

In this phase, coding for the software and test the code.

4) Evaluation
 In this phase, software is evaluated, the current requirements are reviewed and the changes and
additions in the requirements are suggested.

Advantages of an Iterative Model

 Produces working software rapidly and early in the software life cycle.
 This model is easy to test and debug in a smaller iteration.
 It is less costly to change scope and requirements.
 Risks are identified and resolved during iteration; and each iteration is an easily managed
milestone.
 Better suited for large and mission-critical projects.
 During the life cycle, software is produced early which facilitates customer evaluation and
feedback.

Disadvantages of an Iterative Model

 The system architecture is costly.
 This model is not suitable for smaller projects.
 Management complexity is more.
 End of project may not be known which is a risk.
 Highly skilled resources are required for risk analysis.
 Projects progress is highly dependent upon the risk analysis phase.

Spiral model
 It is a combination of prototype and sequential or waterfall model.
 This model was developed by Boehm.
 It is used for generating the software projects. This model is a risk driven process model.
 Every phase in the Spiral model is start with a design goal and ends with the client review.
 The development team in this model begins with a small set of requirements and for the set of
requirements team goes through each development phase.
 The development team adds the functionality in every spiral till the application is ready.
 Following are the steps involved in spiral model:

Phases of Spiral model are:

1) Planning
2) Risk Analysis
3) Engineering
4) Evaluation

1) Planning

 This phase, studies and collects the requirements for continuous communication between the
customer and system analyst.
 It involves estimating the cost and resources for the iteration.
 2) Risk Analysis
This phase, identifies the risk and provides the alternate solutions if the risk is found.

3) Engineering
In this phase, actual development i.e coding of the software is completed. Testing is completed at
the end of the phase.

4) Evaluation
Get the software evaluated by the customers. They provide the feedback before the project
continues to the next spiral.

Advantages of Spiral Model

 It reduces high amount of risk.

 It is good for large and critical projects.
 It gives strong approval and documentation control.
 In spiral model, the software is produced early in the life cycle process.

Disadvantages of Spiral Model

 It can be costly to develop a software model.

 It is not used for small projects.
DevOps Lifecycle
DevOps focuses on bringing all the development, operations, and IT
infrastructure guys, including Developers, Testers, System Admins, and QAs,
under one roof. Hence, all these people together are called DevOps Engineers.

DevOps Engineers share the end-to-end responsibility of gathering information,

setting up the infrastructure, developing, testing, deploying, continuous monitoring,
and fetching feedback from end-users. This process of developing, testing,
deploying, and monitoring keeps on repeating for better results.

You can actually figure it all out from the DevOps diagram illustrated below:
DevOps Tools At Various Stages Of DevOps Cycle:

As you can see below:

 Code: The first step in the DevOps life cycle is coding, where developers build the code on
any platform
 Build: Developers build the version of their program in any extension depending upon the
language they are using
 Test: For DevOps to be successful, the testing process must be automated using any
automation tool like Selenium
 Release: A process for managing, planning, scheduling, and controlling the build in different
environments after testing and before deployment
 Deploy: This phase gets all artifacts/code files of the application ready and deploys/executes
them on the server
 Operate: The application is run after its deployment, where clients use it in real-world
scenarios.
 Monitor: This phase helps in providing crucial information that basically helps ensure
service uptime and optimal performance

 Plan: The planning stage gathers information from the monitoring stage and, as per feedback,
implements the changes for better performance.

Different Lifecycle Stages

Now, let’s discuss the different stages in the DevOps life cycle that contributes to the consistent
software development life cycle (SDLC):

 Continuous Development
 Continuous Integration
 Continuous Testing
 Continuous Monitoring
 Virtualization and Containerization

Now, let’s discuss each of them in detail.

Continuous Development

In the Waterfall model, our software product gets broken into multiple pieces or sub-parts for
making the development cycles shorter, but in this stage of DevOps, the software is getting
developed continuously.

 Tools used: As we code and build in this stage, we can use GIT to maintain different
versions of the code. To build/package the code into an executable file, we can use a reliable
tool, namely, Maven.
Continuous Integration

In this stage, if our code is supporting new functionality, it is integrated with the existing code
continuously. As the continuous development keeps on, the existing code needs to be integrated
with the latest one ‘continuously,’ and the changed code should ensure that there are no errors in
the current environment for it to work smoothly.

 Tools used: Jenkins is the tool that is used for continuous integration. Here, we can pull the
latest code from the GIT repository, of which we can produce the build and deploy it on the
test or the production server.

Continuous Testing

In the continuous testing stage, our developed software is getting tested continuously to detect
bugs using several automation tools.

 Tools used: For the QA/Testing purpose, we can use many automated tools, and the tool
used widely for automation testing is Selenium as it lets QAs test the codes in parallel to
ensure that there is no error, incompetence’s, or flaws in the software.

Continuous Monitoring

It is a very crucial part of the DevOps life cycle where it provides important information that helps
us ensure service uptime and optimal performance. The operations team gets results from reliable
monitoring tools to detect and fix the bugs/flaws in the application.

 Tools used: Several tools such as Nagios, Splunk, ELK Stack, and Sensu are used for
monitoring the application. They help us monitor our applications and servers closely to check
their health and whether they are operating actively. Any major issue detected by these tools
is forwarded to the development team to fix in the continuous development phase.
Let’s now talk about some of the major DevOps tools in the next section of this
DevOps tutorial.

DevOps Tools
The most popular DevOps tools are discussed below.

 Puppet: Puppet is one of the widely-used DevOps tools. It allows delivering and releasing
technology changes quickly and frequently. It has features of versioning, automated testing,
and continuous delivery.
 Docker: Docker is a high-end DevOps tool that allows building, shipping, and running
distributed applications on multiple systems. It helps assemble the applications quickly and is
typically suitable for container management.
 Jenkins: Jenkins is one of the most popular DevOps tools that allow monitoring of the
execution of repeated jobs. Apart from this, Jenkins lets us integrate the changes and access
the results easily and quickly.
 Ansible: This tool helps automate the entire life cycle of an application, and manages
complicated deployments, and enhances productivity.
 Nagios: This DevOps tool helps monitor the IT infrastructure. It is capable of determining
errors and rectifying them with the help of the standard network, server, and log monitoring
systems.