Virtualization Technology News and Information
7 Core Principles for Transitioning to DevOps

By Felix Zoot Billson, Head of Marketing, Global App Testing

DevOps refers to a behavioural change in project management, between software developers (devs) and software operations (ops). It's the latest improvement to agile processes in application development, made possible with cloud automation and orchestration.

The change is designed to shorten the time between changes in coding and the implementation of that code into software operation. 

It's a cultural shift that encourages development and operations to work together, more closely, to ensure a smoother, more efficient, implementation of software updates, without sacrificing quality.



It's a functional change that a lot of companies are embracing, and they're seeing some great results.

But it's not just an overnight software update, it's also a cultural change. And, as such, will take some time to implement. People can be stubborn, and get frustrated with change if it's done haphazardly. To avoid this, you should respect some core principles to help guide you through the transition.

1.   Working Towards a Common Goal

You're essentially merging two separate teams that would previously have worked in isolation. So, it's important to reiterate the idea that, while they are performing different individual tasks, they are working together towards a common goal - a better product for the end user.

Reinforcing a collaborative mentality may sound trivial, but it can have incredible practical effects. It will reduce the "us vs them" mindset that can plague both developers and operators.

It's no longer a case of, "well this isn't my problem." Both developers and operators are responsible for the end product. As they say, a problem shared is a problem halved.

Reconfiguring the Pipeline

Adopting a DevOps strategy requires a complete reconfiguration of the traditional work pipeline. Traditionally, in the "waterfall" model, developers would produce large amounts of code, then wait to deploy it in one large dump. This caused a number of problems.

There's a peak and trough effect that can happen when only one stage of development is occurring at any given time. In the testing stage, for example, all kinds of incompatibility issues and code errors needed to be solved at once, slowing down quality assurance processes (QA processes).



Transitioning to DevOps requires developers to add small sections of code, several times a day.

Constant, smaller chunks of code are far easier to produce and test. It also means that one stage of the pipeline isn't constantly waiting on the other. Every stage of the development process can work independently on more manageable chunks, rather than work being stuck in one stage of the pipeline. 

Transitioning to DevOps is a huge change to the work environment. So, make sure everyone in the development process is on the same page. Remember, this is a collaborative process, so it's vital that everyone is working in unity.

2.   Automation Tools

As DevOps practices encourage smaller software updates, more frequently, you're going to want to ensure that those updates happen as smoothly, and efficiently, as possible.

The best way to do this is by automating as many processes as you can. Rather than having to check every line of code, developers can now use automated software to check any new code for bugs, inconsistencies, or any other errors that might prevent it from being production ready.

With robust automation tools at your disposal, you can ensure a constant flow of developer updates that won't get jammed in the pipeline. The two main types of automation used in DevOps are Continuous Integration and Continuous Deployment.


Image source

3.   Continuous Integration

Continuous integration (CI) is the first of two automated processes integral to DevOps practices. CI is the automation of integrating code changes from numerous developers into a single project.

This means that a number of developers can work on different sections of code for the same project. It can then be integrated automatically with all the other code intended for that project.

4.   Continuous Deployment

The second automated process is Continuous Development (CD). After integrating new code to a software project, CD software can check it for errors. If no errors are found, the new code can be deployed to operations.

Testing in agile has always been a vital stage in the production pipeline. Automating that process is a huge way to improve productivity, and reduce cost.

5.   Encourage Experimentation

One of the main advantages of DevOps operations is the ability to make constant changes that will see operation much sooner than they would before.

This allows developers to try out new things and see how they operate in the real world, far quicker than they could before.

The immediacy of this process should encourage your developers to experiment with different solutions. Because they are coding smaller sections at a time, they can focus on that one section, and attempt a number of possible updates, and just see how they pan out.

The waterfall methodology makes this much harder, as large sections of code have to be locked in before moving to the nest stage.

The more agile practice allows smaller adjustments to be made constantly without having to clamber back up the waterfall (agile vs waterfall).

6.   Encourage Failure

Obviously, not everything your developers come up with is going to be pure gold. But mistakes aren't as costly as before. The previous waterfall methodology put a lot of pressure on developers to get it perfect the first time, as every mistake would require taking a costly step backwards.

DevOps, however, breaks each problem into manageable chunks that can be easily altered if it doesn't go the way intended. This doesn't just save time, it also takes some pressure off, allowing your developers to try different solutions without fear of recrimination.

The key here is fostering an environment that better enables creativity, and ingenuity. And remembering that failure is a vital part of every creative process.

7.   Get Regular Feedback

This is where the Ops comes into DevOps. One of the main advantages of bringing these two departments together is that operators can report back on any software changes made by developers.

This completes the DevOps process. Constant developer updates, implemented quickly, being reviewed by the actual people using the system.

They can let developers know what's working, and what's not. It's another dimension to Quality Assurance that includes operators in QA best practices.

It's the best way to improve your systems; smaller changes receiving constructive, immediate feedback.

Practically, it's the best way forward. Crucially, this kind of feedback cycle will include your operators in the creative process, reinforcing the collaborative aspect at the heart of DevOps practices.

Closing Thoughts

DevOps is an evolution of agile project management. But, it's likely to keep evolving as technology, and human ingenuity find ways to further refine the process.

The great thing about DevOps is that it is innately responsive to flexibility and change.



Felix Zoot Billson - Head of Marketing, Global App Testing 


Felix Zoot Billson is the Head of Marketing for Global App Testing, a company that can address your QA test and function test needs. Global App Testing is founded on speed, impact and effort. Felix has become adept at growing businesses by focusing on creating optimized customer experiences to maximize business impact and revenue. On the weekends, you'll find him reading his favorite novels and mountain biking. Here is his LinkedIn.

Published Thursday, June 17, 2021 7:34 AM by David Marshall
Filed under:
There are no comments for this post.
To post a comment, you must be a registered user. Registration is free and easy! Sign up now!
<June 2021>