We're live-coding on Twitch! Join us!
Understanding the Difference Between Agile and DevOps (Complete Guide)

Understanding the Difference Between Agile and DevOps (Complete Guide)

Earlier Agile development was the front & center of the conversation about software development. Now DevOps has taken over the conversation.

_How agile and DevOps are linked? _

The two ideas started as ways to improve different aspects of software development. Agile has embraced the changing nature of requirements and prioritized working software over rigid processes.

DevOps has reduced development and operations silos to improve development and production operations. Each shares basic ideas, but each targets different stakeholders and sets different business goals.

Given the overlap, people ask if DevOps is agile or if we are doing DevOps, should we also be agile? Or, is agile still relevant? Or, what's the point of any of these things anyway?

This article answers these questions and also shows how DevOps is different from agile and that both are still useful and necessary for successful software development.

Context and Background

Agile development dates back to the 1990s with practices such as Scrum, Extreme Programming (XP), feature-based development and user stories. The agile manifesto was written in 2001 by prominent software developers like Martin Fowler, Ward Cunningham, Bob Martin & Kent Beck. The main section of the manifesto reads with bold reflections:

“Individuals and interactions over processes and tools Working software over comprehensive documentation Responding to change over following a plan Customer collaboration over contract negotiation"

Agile was a response to constrain software development processes. The idea was to be flexible, iterate, work with stakeholders to produce software that meets their needs while increasing predictability. Generally speaking, agile development is a set of practices for developing software as a team and largely focused on planning and requirements.

DevOps dates back to the late 2000s and early 2010s. Organizations typically had dedicated development and operations teams where development tossed their compiled code over the wall to operations for execution. This created problems because operations were disconnected from the code they were supposed to support in production, and development was also disconnected from the operational side of their software. Each group had conflicting goals. Operations wanted stable environments and to minimize change. Development needed to ship functionality as quickly as possible to create new product functionality. These two groups fundamentally disagreed. The idea of ​​DevOps was to break the silo between operations and development (hence "dev" and "ops") and replace it with a shared feedback loop. Today, DevOps is an umbrella for technical practices like continuous integration, continuous delivery (or deployment), high levels of automation and cross-functional teams.

There is no official manifesto, but the DevOps manual is the best reference for the ideas and practices behind DevOps. The DevOps manual describes the three methods of DevOps:

The principle of flow: reduce the time between validation and execution of the code in production. This metric is called delivery time. The principle of feedback: increase feedback from production to development (through practices like automated alerts & real-time monitoring). The principle of continuous learning and experimentation: continuously improving and evolving processes

Each principle requires technical practices such as building a continuous delivery pipeline, adding the required production telemetry and performing failure autopsies.

In other words, Agile tackles the problem of creating software and DevOps focuses on bringing the code into production and improving this process. Each covers a different, but equally valuable, part of software development. Agile set the stage for DevOps. Agile provides teams with a way to create software faster and therefore deploy it more often. DevOps provides teams with a formula for deploying more often and high quality.

How Agile and DevOps Differ

Agile and DevOps each target different SDLC players. Agile covers project management and require highly defined roles as Product Owner. DevOps targets more technical work and requires engineers to accept shared responsibility for creating and deploying software while demanding that management and product owners think their software in a certain way.

Here's how it works in practice.

There are many different methodologies such as kanban or melee. Both focus on the procedure for accomplishing the tasks, regardless of the technical details. Kanban has a set of principles to limit work in progress, follow bottlenecks and promote visibility. Scrum aims to make software development more predictable by setting a fixed time and scope for a sprint, then letting the team organize and resolve issues as they arise. This is where many people come across agile development and it is often guided by the software the team uses to track work.

DevOps intervenes when the code must be written. The first principle of DevOps focuses on coding and then production. It makes no assumptions about the process used to specific customer requirements or how to prioritize a backlog.

The principle is simple: all work done must be sent to production as quickly as possible. However, the successful implementation of DevOps requires a development back pressure provided by agile methodologies. It is the opposite of the development of the cascade, which is incompatible with DevOps and because with is the antithesis of Agile.

Agile requires fixed roles and responsibilities. The Product Owner (or PO) is probably the most important role since the PO is responsible for defining the requirements and clarifying the operation of the product for engineers.

Scrum uses a dedicated scrum master to manage the process. There are even certifications for foam masters. DevOps makes no proclamation on dedicated roles. DevOps is closer to a set of behaviors than to a defined role. In fact, there is a tendency in the industry to post "DevOps Engineer" positions. This goes against DevOps ideas of shared responsibility and technical practices. DevOps cannot be a dedicated role.

Agile-Backed DevOps is the Way Forward

It should be clearer now how Agile and DevOps are both ideas and apply to different areas of the SDLC. Agile is a framework for product creation and DevOps is a set of technical practices for the deployment and execution of production systems. Since these two ideas are different and just as powerful, you need to adopt both in your SDLC.  Agile practices such as pair programming are a great way to distribute knowledge and improve the quality of code, whatever the purpose of the code. Such practices can produce new functionality, fix bugs with internal tools, or lead to code infrastructure in your deployment pipeline. DevOps calls for shared responsibility and an understanding of the deployment pipeline and other associated infrastructure. Pair programming is a great way to expose engineers to this environment and develop their knowledge

Again, agile development practices apply to most software projects, whether through the product backlog or by developing internal tools. All software projects benefit from faster cycle times and faster production returns. In fact, it is the key to a successful agile process.

The agile process focuses on stakeholder feedback resulting from interaction with working software. Faster working software is made available to stakeholders, changes happen faster, so the overall process speeds up. Adopting agility without introducing DevOps principles will inhibit the speed of your organization and slow the pace of your software version

Accelerate - The science of Lean Software and DevOps: creation and scaling of high-performance technological organizations study the characteristics of the best performing teams. The authors find that the implementation of DevOps practices such as trunk-based development and continuous delivery are clear indicators of high performance. Their 2017 research revealed that the top performers compared t

  • 46 times more frequent code deployments

  • 440 times faster lead time from committing to deploy

  • 170 times faster mean time to recover from downtime

  • 5 times lower change failure rate (1/5 as likely for a chance to fail)

The first two points stand out because they have shown how fast an agile process supported by DevOps can be. These factors build on each other to create more successful businesses. In fact, Accelerate also found that the top performers had a 50% higher market capitalization growth over three years compared to the underperformers. Again, keep in mind that these achievements are possible when the agile process provides adequate backpressure for DevOps behaviors.

Conclusion

This post covered the relationship between Agile and DevOps as well as their historical context and their target area. Just looking at the story, we see that DevOps is a technical continuation of Agile's ideas. Both philosophies favor rapid iterations and rapid reactions to changing conditions. These are similar ideas but target different phases of the SDLC.

The best performing teams apply agile development practices and DevOps deployment practices. Chances are your organization is already working with agile development in one way or another. Improving your DevOps practices is the next step to increasing speed and quality in your organization.

Read more here: Kubernetes vs. Docker Swarm: How to Choose? | A Complete Breakdown (https://www.goodworklabs.com/kubernetes-vs-docker-swarm-how-to-choose-a-complete-breakdown/)

Like this article? Follow @UmeshSaha1 on Twitter