UNIT- I

Introduction to SDLC:
1. Software development life cycle (SDLC) is a structured process that is used to
design, develop, and test good-quality software.
2. SDLC is a methodology that defines the entire procedure of software
development step-by-step.
3. The goal of the SDLC life cycle model is to deliver high-quality, maintainable
software that meets the user's requirements.

Stages of the Software Development Life Cycle

 SDLC specifies the task(s) to be performed at various stages by a software

engineer or developer. It ensures that the end product is able to meet the
customer's expectations and fits within the overall budget. Hence, it's vital for a
software developer to have prior knowledge of this software development
process.
 SDLC is a collection of these six stages, and the stages of SDLC are as follows:

Software Development Life Cycle Models

There are over 50 recognized SDLC models in practice, However, none of them is
perfect.we have listed the top five most popular SDLC models
1. Waterfall Model
2. Agile Model
3. Iterative Model
4. Spiral Model
5. V-Shaped Model
Among these, the Waterfall model were widely used where as the Agile model are
the most widely use presently.

Waterfall Model
 It is the oldest SDLC model and is also known as the Linear Sequential
Model.
 In this model, each phase must be completed before the next phase can begin,
and there is no overlapping of phases. All phases are performed sequentially,
one after the other, just like water flowing downwards in a waterfall.
Advantages:
 It is very simple and easy to implement.
 Since the phases do not overlap, there is no ambiguity.
 All phases are executed one after the other, providing high visibility to
project managers and clients regarding the progress of the project.
 It is best suited when the requirements are fixed and is most suitable for
small projects.
Disadvantages:
 It is a very rigid model because it does not accept requirement changes in the
middle of the development process.
 Client satisfaction is often low, as clients usually add new requirements
during development, which this model does not support.
 The total project development time is longer because testing is done only
after the development phase is completed.
 The cost of bug fixing is very high, as bugs cannot be identified in the early
stages of the lifecycle.
 It is not suitable if the requirements keep changing.
 It is not suitable for large and complex projects.

Agile model
 The Agile model is an iterative and incremental approach to software
development that focuses on delivering small, workable pieces of software
quickly and efficiently.
 It emphasizes flexibility, collaboration, customer feedback, and rapid
delivery.
Agile Manifesto principles include:

 Individuals and interactions over processes and tools

 Working software over comprehensive documentation
 Customer collaboration over contract negotiation
 Responding to change over following a plan

Relation with DevOps:

DevOps extends Agile by focusing on continuous integration, testing, deployment,
and operations, emphasizing both development and delivery.
·
Steps in the Agile Model
The Agile Model is a combination of iterative and incremental process models. The
phases involve in Agile (SDLC) Model are:
1. Requirement Gathering
2. Design the Requirements
3. Construction / Iteration
4. Testing / Quality Assurance
5. Deployment
6. Feedback

Key Characteristics of Agile Model:

 Iterative Development: The project is divided into small iterations or sprints
(usually 2-4 weeks), and working software is delivered at the end of each
iteration.
 Incremental Delivery: Each iteration adds new features to the existing
software, gradually building up the complete product.
 Customer Collaboration: Continuous involvement of the client or product
owner to refine requirements and priorities based on feedback.
 Adaptive to Changes: Agile welcomes changes in requirements even late in
the development process.
 Cross-functional Teams: Teams consist of developers, testers, and business
stakeholders working collaboratively.
 Continuous Testing: Testing is done in every iteration to ensure high-quality
deliverables.

Popular Agile Methodologies or Sub Models:

Agile Model is divided into several sub models
 Scrum: Uses fixed-length sprints and roles like Product Owner, Scrum
Master, and Development Team.
 Kanban: Focuses on visualizing workflow and limiting work in progress.
 Extreme Programming (XP): Emphasizes technical practices like pair
programming, continuous integration, and test-driven development.
Among all these models Scrum model is the most popular and frequently used model.
Scrum is derived from Rugby Game.

Scrum:
A popular Agile framework used to manage product development.
Key Components:
Roles: Product Owner, Scrum Master, Development Team
Artifacts: Product Backlog, Sprint Backlog, Product Increment
Events: Sprint, Sprint Planning, Daily Scrum, Sprint Review, Sprint Retrospective
Sprint Cycle:
Iterative cycles (usually 2-4 weeks) where a usable product increment is delivered.
Advantages of Scrum Model:
 There is maximum chance for quality
 It ensures effective use of time and money
 Requirement changes will be accepted so that maximum chance for client
satisfaction
 There is a possibility for the client involvment in every stage
 Project status Tracking is very easy
 Team gets complete visibility through scrum meetings

Limitation of Scrum model

 The chances of project failure is very high if individuals are not committed or
cooperative
 Adapting scrum model for large teams is very big challenge
 Must required experienced and efficient team members
 If any team member leaves in the middle of project,it can have a huge
negative impact on the project.

Kanban
A visual method for managing workflow to balance demands with available capacity.
Key Principles:
 Visualize work
 Limit work in progress (WIP)
 Manage flow
 Make process policies explicit
 Improve collaboratively
Kanban Board:
Columns representing stages (To Do, In Progress, Done)
Cards representing tasks that move across columns

Introduction to DevOps:

1. DevOps is a combination of Development and Operations.

2. It promotes collaboration between developers and operations teams to deliver
software quickly and efficiently.
3. The concept originated when Patrick Debois organized DevOpsDays in 2009
after observing a divide between development and operations teams.
4. Goal: Break down barriers between teams, automate processes, and ensure faster,
continuous delivery of software.

DevOps Phases Overview

Plan → Code → Build → Test → Release → Deploy → Operate → Monitor

 Plan - In the planning stage, it is important to identify both business and end-user
requirements. Professionals also design a project plan to meet established criteria
and deliver the best possible product.
 Code - At this stage the team works on code development. To facilitate code
production, the development team uses various version control tools and
extensions, for example, Git, which helps them maintain good code practices and
manage the product properly.
 Build - After the coding stage, developers submit code to a shared repository with
the help of build tools, such as Maven or Gradle.
 Test - Ensuring software quality is another crucial stage. If the building stage is
ready, the quality assurance team performs a series of tests, such as user
acceptance tests, security tests, speed tests, integration tests, etc. They usually use
tools like JUnit or Selenium.
 Release - In this stage, the team prepares and marks artifacts for deployment
(container images, code packages, binary files, or patches). Basically, at this
point, a specific build is selected from stage number three.
 Deploy - In this stage, the build is released with the help of DevOps lifecycle
tools, for example, Docker, Nomad , or Amazon Web Services.
 Operate - The release is ready to use. The operations department manages server
configuration using DevOps tools such as Chef, Ansible, and Puppet to make the
new version accessible to users.
 Monitor - Based on collected data about consumer behavior and application
performance, the DevOps workflow is assessed. Observing the whole
environment helps to identify bottlenecks that negatively impact operations and
production team performance.

DevOps Process and Continuous Delivery – Overview

What is Continuous Delivery (CD)

 Continuous Delivery ensures that software is always ready to be deployed to

production at any time.
 It involves automating the entire software delivery process, from code commit
to deployment, ensuring fast, reliable releases.

1. Developers

Role: Write and commit code regularly to the version control system.

Best practice: Commit small, frequent changes instead of large chunks to

reduce errors and merge conflicts.

Tools: Git, GitHub, GitLab

2. Revision Control System

Purpose: Stores and manages different versions of code, allowing team

collaboration.

Benefits:
  Tracks changes
 Enables rollbacks if something goes wrong
 Supports branching and merging

Examples: Git, SVN, Mercurial

3. Build Server

Function: Automatically compiles the source code into executable files

whenever changes are committed.

Role in CD: Automates builds, runs tests, and prepares code for deployment.

Popular Tool: Jenkins (fetches code, builds it, and triggers further stages like
testing or deployment)

4. Artifact Repository

Definition: Central location to store built files (artifacts) like compiled code,
libraries, or packages.

Purpose: Ensures built artifacts are versioned, reusable, and accessible for
deployment.

Examples: Nexus, Artifactory

5. Package Managers

Role: Manage dependencies (libraries, modules) required for the software to

run.

Examples:

 For Java: Maven, Gradle

 For Python: pip
 For Node.js: npm

6. Test Environments

What it is: Separate environments that mimic production to test code safely.

Purpose: Run automated tests to catch bugs and ensure software works as
expected before deployment.

7. Staging/Production

Staging Environment:

Almost identical to production.

 Used as the final testing environment to ensure the system works well
in real-world conditions.

Production Environment:

Live environment where the software is accessible to end users.

Requires highest stability and security.

7Cs DevOps lifecycle

1. Continuous Development

What it is: Planning and coding phase where project requirements are
discussed, backlog is created, and development happens continuously for
every change or performance issue.

Example:
Nordstrom (US retail chain) moved from Waterfall to DevOps with
continuous development and a single backlog, reducing bugs and increasing
releases from twice a year to monthly.

Tools Used:
Version control – Git, GitLab, SVN, Mercurial, BitBucket, TFS, Subversion
Project management – Jira, Confluence
Practices – Scrum, Lean, Kanban
(Git and Jira are most popular)

2. Continuous Integration

What it is: Frequently integrating new code with existing code, running unit
tests at each commit to detect and fix bugs early.

Example:
DocuSign adopted DevOps using mock tools for internal API testing,
improving integration and delivery speed for their e-signature services.
 Tools Used:
Jenkins (widely used open-source tool), Bamboo, GitLab CI, Buddy,
TeamCity, Travis, CircleCI
(Choose tools based on project needs)

3. Continuous Testing

What it is: Automated testing phase before or after integration to find bugs
quickly, sending failed code back for fixes, ensuring quality with less time and
effort.

Tools Used:
Selenium (most popular for automation), JUnit, TestNG, TestSigma (AI-
driven testing platform)

4. Continuous Deployment

What it is: Deploying final code to production servers continuously with

configuration management ensuring smooth and consistent deployment across
environments.

Example:
Adobe uses CloudMunch DevOps platform to manage deployments
efficiently, enabling faster software delivery with better product management.

Tools Used:
Configuration management – Ansible, Puppet, Chef
Containerization and deployment – Docker, Vagrant
Continuous delivery – Spinnaker, ArgoCD

5. Continuous Feedback

What it is: Regularly analyzing customer behavior and feedback after each
release to improve future versions.

How feedback is collected:

Structured: Surveys, questionnaires

Unstructured: Social media comments, reviews

Example:
Tangerine Bank (Canada) used continuous feedback to quickly identify and
fix mobile app issues, improving customer experience and saving resources.

Tools Used: Pendo (product analytics), Qentelli’s TED (tracks DevOps

process for insights)
6. Continuous Monitoring

What it is: Continuously checking app performance and features to detect

issues like low memory or server errors.

Purpose: Helps IT teams quickly find and fix problems; security issues can
also be detected and resolved automatically.

Tools Used: Nagios, Kibana, Splunk, PagerDuty, ELK Stack, New Relic,
Sensu

7. Continuous Operations

What it is: Automating app updates and launches to reduce downtime (e.g.,
during maintenance).

How it helps:

Avoids taking servers offline

Ensures high availability and faster deployment

Tools Used: Kubernetes, Docker Swarm (for container orchestration and

deployment on multiple environments)

DevOps and ITIL

ITIL (Information Technology Infrastructure Library):

 It is a framework used by large organizations to manage their IT services in a

structured way.
 Provides detailed practices for IT service management, including incident
management, problem management, change management, etc.

DevOps vs ITIL:

 DevOps focuses on continuous software delivery and collaboration where as

ITIL focuses on IT service management and processes.
 Integration: Modern organizations integrate ITIL’s structured processes with
DevOps agility for efficient service delivery.
 DevOps brings speed and automation; ITIL ensures structured management
and control, especially for large legacy systems.

Release management
Process of managing, planning, scheduling, and controlling software builds through
different stages and environments.
Key Activities:
Planning release schedules
Building and packaging software
Deploying releases to production
Coordinating with stakeholders for approvals and readiness
Goal: Deliver new features and fixes efficiently while maintaining system stability
and integrity.

Delivery Pipeline
Automated process of moving software from version control to production
deployment.
Stages in a Delivery Pipeline:
Commit Stage: Code changes committed and built
Automated Testing Stage: Unit tests, integration tests executed
Staging Deployment: Deployed to staging environment for further testing
Production Deployment: Final deployment to live environment
Benefits:
Faster and reliable deployments
Reduced human errors
Easy rollback in case of failures

Identifying bottlenecks
Bottlenecks are points in the process where the flow is limited, slowing down the
entire system.
Common DevOps Bottlenecks:

1. Manual Testing Delaying Release

Explanation:
When testing is done manually, it takes a lot of time to check every
functionality, especially as the software grows. This delays the feedback cycle
and release of new features or bug fixes.

Impact:

 Slower delivery
 Increased chances of human error
 Less frequent releases

Solution:
Implement automated testing tools like Selenium, JUnit, or TestNG to run
tests quickly and repeatedly without manual intervention.

2. Approval Processes Taking Too Long

Explanation:
In traditional workflows, approvals for deploying code to production require
multiple managerial or stakeholder sign-offs, which can cause delays.

Impact:

 Slows down deployment cycles

  Frustrates development teams waiting for approval
 Reduces agility and responsiveness to customer need

Solution:
Streamline approvals using automated workflows, clear policies, and
DevOps practices like automated pipelines with required security and
compliance checks embedded.

3. Inconsistent Development Environments

Explanation:
Developers, testers, and production may use different environments or
configurations. For example, a feature working on a developer's laptop may
fail in production because of different OS versions, dependencies, or settings.

Impact:

 Bugs that are hard to detect and fix

 Deployment failures
 Reduced confidence in code quality

Solution:
Use containerization tools like Docker to create consistent environments
across development, testing, and production, ensuring “it works on my
machine” issues are eliminated.

4. Lack of Automated Deployment

Explanation:
Deploying code manually to servers is time-consuming, error-prone, and often
requires downtime. Each manual deployment step increases risk.

Impact:

 Delays in releases
 Higher chances of deployment errors
 Downtime affecting users and business

Solution:
Implement automated deployment tools and scripts using tools like Jenkins,
Ansible, or Kubernetes, enabling continuous deployment with minimal manual
effort and faster, safer releases.