Automation is the glue that brings Agile and DevOps together, by helping teams better collaborate, design, code, test and deploy high quality software faster and more reliably.
Introduction
Terms like Agile and DevOps often seem synonymous, both painting mental pictures of collaboration and continuous software releases and delivery. They’re both relevant in the software space, and many companies have found success in using one or both these methodologies.
But there’s still a lot of confusion between Agile and DevOps, especially around their implementation. It’s not uncommon for individuals to mistake one for the other, and thereby arises the need to de-mystify these topics. This article details some of the key differences between the Agile and DevOps methodologies and how Automation comes into the picture.
But, before diving straight into how Agile and DevOps differ from each other, it might be helpful to set some context about the world of software development. Software development began around the 1950s and one of the first formal software development methodologies came into existence around the mid-1970s; called Waterfall. In 2001, a group of seventeen software engineers drafted the “Agile Manifesto”, which discussed the principles of the software development methodology called Agile. The term DevOps became popular in 2009, through a series of conferences called ‘DevOpsDays’, which called for increased cooperation between development and operations teams. Waterfall, Agile and DevOps are some of the most commonly used and talked about software development methodologies, and they will be further discussed below.
Software Development Methodologies
Waterfall
Software flows from one distinct stage of its production cycle to the next in the Waterfall methodology.
The traditional Waterfall methodology is the de-facto standard for software development. It was how teams first started building software and even with the rise of newer development processes, is still the most widely used approach. Here, phases of the Software Development Life Cycle (SDLC): requirements, design, development, testing and maintenance; form a linear sequence, each phase separate from the other. Software requirements are planned and designed by product owners and designers. These requirements are then passed on to developers who write code and create the software which is then sent to QA teams for testing. After rounds of testing and debugging, software will finally be deployed and monitored by systems and operations teams. This siloed approach resembles a waterfall, where software gets shaped and unidirectionally pushed from one level to the next.
The waterfall methodology provides clear, concise steps and documentation which can be great for short projects with a predictable scope. It doesn’t have a steep learning curve as project requirements and steps are clearly defined and can be useful in highly regulated industries where changes from the design during development are hardly allowed. There are pros and cons to the Waterfall approach but one issue that is constantly brought up is time. Sometimes, it takes months to plan and decide the requirements of the software. Coding, testing, re-coding and re-testing the software can take a long time as well, meaning software deployment isn’t possible until late into the SDLC. It’s not uncommon for software to take over a year to be released with the Waterfall methodology in large projects. Longer projects also drive up cost, exposing the organization to a large amount of risk. It is also worth noting that testing is much more difficult when working in a waterfall process. Since all the code is written before testing begins, teams will sometimes find major errors that require a ton of reworking to fix. Time and effort aren’t the only factors; customer requirements are frequently changing, and ordinarily cannot be included into the current release just because of the nature of the Waterfall methodology. This leads to the release of outdated software caused by dynamic customer requirements which cannot fit into the scope of the current Waterfall cycle.
Agile
Agile methodologies accelerate software development through cross-functional collaboration.
The delay in software delivery and the rigidity associated with the Waterfall methodology drove the software industry to seek a faster, less-siloed and more iterative methodology, birthing the Agile methodology. Agile is a highly collaborative approach to creating software which depends on quick development and releases through incremental builds. Here, designers, developers and testers work closely in small teams which communicate daily. The focus is on early software delivery and adapting to moving targets. Unlike Waterfall, Agile methodologies don’t involve writing large requirement documents which take ages to draft. This minimizes the risk of the developed software becoming obsolete by prioritizing tasks and reacting to changes in every sprint through continuous feedback. Agile also necessitates cross-functional teams, where designers, developers and testers have the knowledge to take on a wide range of tasks. This way, teams can continuously develop software, which fulfils the basic, minimum customer requirements in one build, and can then continuously improve and integrate new features or fixes in subsequent builds, thereby allowing continuous software releases. This aligns with the principle, that “working software is the primary measure of progress”, as outlined in the Agile Manifesto. One of the other benefits of agile methodologies is that it allows teams to be more responsive to change. For example, if you are doing work for a client, it’s easier to get them what they want if you are constantly showing them bits and pieces of your development process and gathering their feedback. It is a nightmare if you’ve spent 6 months developing and the client takes a single look at the end result and says, “this isn’t what I was expecting at all!”
DevOps
DevOps allows for reliable and continuous delivery of software, with minimum disruption to existing infrastructures.
Software development is only one side of the spectrum, the other side being software deployment. Creating software as quickly as possible will be useless if the current structures in place can’t deploy the software just as swiftly. This calls for increased collaboration between software development and operations teams. This is where DevOps comes into the picture, where network, security, systems and operations teams also play an involved role in the SDLC with product owners, developers, testers, etc. It often works as an extension of the Agile development process by further encompassing the software delivery side of the SDLC. Bringing in operations teams earlier in the SDLC, allows them to plan and prepare for the work they expect to come their way. In this sense, DevOps embodies the spirit of cross-team collaboration, by breaking down barriers of communication between the previously siloed development and operations teams. It also aims to minimize manual hand-offs between different teams by creating tighter feedback loops and mitigating process gaps through lean techniques. DevOps also significantly reduces risk by making deployment much easier.
Although Agile and DevOps are similar in that both methodologies preach continuous feedback, frictionless communication and collaboration, the application of DevOps to the operations side of the SDLC is not the only factor which distinguishes it from Agile.
Agile vs DevOps
Objective:
- Agile teams focus on developing software rapidly and iteratively.
- DevOps teams also focus on deploying quality software quickly and reliably, in addition to developing software rapidly.
Team Dynamics, Composition and Size:
- Agile teams include business folk, designers, developers and testers and are usually less than ten in number. These small teams are highly flexible, adaptive and cross-functional.
- DevOps is on a larger scale than Agile, since they include operations, systems, network and security teams in addition to design, development and testing teams. They rely on cross-team collaboration and continuous feedback.
Communication Type and Frequency:
- Agile teams have daily, face-to-face scrum meetings that are unstructured and informal.
- DevOps teams are highly dependent on communication, however their meetings aren't always daily, informal or face-to-face.
Documentation:
- Agile teams rely more on meetings and don't focus so much on lengthy, comprehensive documentation.
- DevOps teams need to fully understand new software releases and their specifications, and therefore rely on heavy documentation.
Scheduling Features and Speed:
- Agile teams work incrementally in sprints that last between a week to a month. They focus on developing shippable software every sprint.
- DevOps teams focus on continuous deployment of software that is minimally disruptive. They can safely release software up to several times a day.
Planning for Unplanned Work:
- Agile teams can keep track of planned work with practices like Kanban and Scrum.
- DevOps teams are conditioned to react to unplanned work in the software delivery process, such as security failures and load spikes, by working closely with operations teams.
Role of Test Automation in Software Development
Iron Triangle
Agile and DevOps methodologies differ on many accounts. However, the importance of automation in both methodologies is an undeniable link that binds the two together. Time, cost and quality are the three constraints of project management; they form the iron triangle. An underbudget, rushed project will invariably have bugs and suffer in quality. Similarly, developing high quality software quickly will be expensive if everything is done manually. Automation helps conquer the constraints of time, cost and quality in the iron triangle. It is a cost-effective solution to accelerate software development while ensuring quality through earlier bug identification and quicker fixes.
Shift Left
Agile team members are proficient in taking on multiple roles and often embrace automation to design, develop and test their software. Developers who want to test are embracing the “shift-left” ideology and are automating testing at the developer level. On the other hand, designers or managers who cannot code, but want to try their hand at testing can take advantage of scriptless automated testing functionalities to record tests and replay them for numerous use cases.
Scriptless Automation
Agile team members are proficient in taking on multiple roles and often embrace automation to design, develop and test their software. Developers who want to test are embracing the “shift-left” ideology and are automating testing at the developer level. On the other hand, designers or managers who cannot code, but want to try their hand at testing can take advantage of scriptless automated testing functionalities to record tests and replay them for numerous use cases.
Continuous Integration/Continuous Delivery
Automation is also at the heart of DevOps. Infrastructure management, continuous integration (CI) and continuous delivery (CD) through automation can help DevOps teams accelerate their software deployment. With CI, every line of code released is automatically merged and built into the system, while CD allows for changes, updates or fixes to be delivered on-demand in a safe and reliable manner. Developers can also shift-left and use automation tools to create BDD test cases in the development phase. Furthermore, by automating workflows, discrete teams can focus on improvements from a systems perspective to deliver the maximum business value.
Conclusion
Therefore, no matter the methodology, automation helps teams accelerate software development and deployment efforts to get high quality software to customers on time. Agile and DevOps teams can use automation to better design, collaborate, code, test and deploy better software anywhere, anytime.