Rawpixel - Fotolia
- Brian Kirsch, Milwaukee Area Technical College
The DevOps methodology is more than just a flavor-of-the-month buzzword. It's a new way to do things that can help catapult a business ahead of the competition. Synergy between development and operations incorporates automation and monitoring for quicker development and a deployment cycle that's designed to improve release quality and scheduling.
That's the formal description anyway. But is that really what DevOps is about? A DevOps methodology is not the solution to all IT problems, but it's not a waste of time.
Organizations must first look at the development piece of the DevOps puzzle. Developers are a special bunch -- even more so than most IT groups. This isn't because they are hardline coders sitting in a back room somewhere writing caffeinated code for hours on end. (OK, the caffeine part is true.) Developers are creators of applications designed to move a company forward. While there are a lot of technical pieces to coding, designing an application requires creativity and artistic ability that often gets overlooked. The creation of applications from scratch is not easy.
In today's IT world, the focus is less on OSes and infrastructure and more on the application -- a dynamic that puts a new focus on development.
Change is good, until it isn't
While developers create applications that the business needs, they are not always the heroes of the business. This is because at a basic level developers seek change; they are often working on the applications to add and adjust. While this is beneficial, uncontrolled or excessive changes lead to application crashes, poor performance and, eventually, dissatisfied customers. These problems aren't intentional, of course, but excessive change creates instability, which is why developers also need some guidance and control. Even mentioning the word control can generate anxiety and spur difficult conversations.
DevOps concepts put a lot of focus on how important development is, but that doesn't mean it's a get-out-of-jail-free card. Too often, organizations use DevOps to focus on reducing lead times and moving faster. While these are good goals, you typically don't need to encourage development teams to move faster.
Instead, DevOps should focus on turning the conversation to difficult topics such as control and quality. DevOps methodologies already empower development teams to focus on the things they want -- such as quicker releases and more changes -- but should also emphasize aspects developers aren't as familiar with.
For development teams to succeed, they need to understand the challenges associated with the frequent release concept. Some will say that is difficult for the operations side of the house. But if development teams don't embrace the need for control, you won't have a true DevOps effort and won't reap the benefits of the combination.
Take a stake
A successful approach to DevOps methodology requires development teams to take some ownership in the operations process. First, organizations must help development teams understand how application changes affect both operations and customers. They should begin to see they have a vested interest in the success of the entire process.
DevOps is not about ops controlling dev, but about both groups taking a stake in the entire process. This won't be easy, but solid communication from management and incentives based on overall success -- as opposed to development-specific incentives or goals tied to speed -- help all teams focus on the needs of the business and customer.
All this sounds ideal on paper, but people don't always buy in, or they quickly revert to old ways. It will be up to management to avoid simply handing down a DevOps mandate and then walking away. The DevOps process must be reinforced at every turn as a positive method for both the company and the people on the ground making it happen.
Everyone needs to take ownership. Any DevOps journey will experience peaks and valleys, but, if you stick through failures, the benefits can yield impressive results.