The three ways can guide your strategic approach to DevOps.
(epic music) - Welcome back. Let's talk about principles you can use to guide you in taking the core DevOps values and bringing them to life. The most respected set of principles is called The Three Ways. This model was developed by Gene Kim, author of "Visible Ops" and "The Phoenix Project," and Mike Orzen, author of "Lean IT." The three ways they propose are systems thinking, amplifying feedback loops, and a culture of continuous experimentation and learning.
The first way, systems thinking, tells us that we should make sure to focus on the overall outcome of the entire pipeline in our value chain. It's easy to make the mistake of optimizing one part of that chain at the expense of overall results. When you're trying to optimize performance in an application, for example, increasing performance or system resources in one area causes the bottleneck to move sometimes to an unexpected place. Adding more applications servers, for example, can overwhelm a database server with connections and bring it down.
You have to understand the whole system to optimize it well. The same principle applies to IT organizations. A deployment team might establish processes to make their own work go smoothly and their productivity numbers look good, but those same changes could compromise the development process and reduce the organization's overall ability to deliver software. This overall flow is often called "From Concept to Cash." If you write all the software in the world but you can't deliver it to a customer in a way that they can use it, you lose.
The split between development and operations has often been the place where the flow from concept to cash goes wrong. Use systems thinking as guidance when defining success metrics and evaluating the outcome of changes. The second way, amplifying feedback loops, is all about creating, shortening, and amplifying feedback loops between the parts of the organization that are in the flow of that value chain. A feedback loop is simply a process that takes its own output into consideration when deciding what to do next.
The term originally comes from engineering control systems. Short, effective feedback loops are the key to productive product development, software development, and operations. Take the story of a simple bug. If that bug is found by the developer before they check it into source control because tests on their desktop catch it, you've eliminated a problem with very little time wasted. If that bug gets past that point and is found by a QA team, documented in a ticketing system, and then pushed back to a developer to fix, it's still resolved, but with more time wasted.
If it gets all the way into a customer release, and is encountered by end users, logged with a support organization, churned over in support, escalated back to development, or re-prioritized by a product manager, and then fixed, it wastes even more time and money for a same or worse outcome. Effective feedback is what drives any control loop designed to improve a system. Use amplifying feedback loops to help you when you're creating multi-team processes, visualizing metrics, and designing delivery flows.
The third way reminds us to create a work culture that allows for both continuous experimentation and learning. You and your team should be open to learning new things and the best route to that is actively trying them out to see what works, and what doesn't work, instead of falling into analysis paralysis. But it's not just about learning new things, it also means engaging in the continuous practice required to master the skills and tools that are already part of your portfolio.
The focus here is on doing. You master your skills by the repetition of practice. And you find new skills by picking them up and trying them. You may have heard other technologists say things like, "Working code wins," "If it hurts, do it more," and "Fail fast." These all speak to this kind of culture, which retains a practical focus on doing instead of just talking about doing. Use the third way, a culture of continuous experimentation and learning, when creating team processes and standards, and as part of your leadership style.
Encourage sharing and trying new ideas. Engineers are problem-finders and problem-solvers by nature, and that can often turn into negativity about new technologies or avoiding attempts to try new things, from "Not Invented Here" Syndrome, to deliberate attempts at niche protection. Acknowledge and overcome these temptations on your path to excellence. No technology, not even new wiz-bang technologies like Docker or Amazon Web Services, is a silver bullet that solves all of your problems.
It's how you use them that matters most. As you continue your DevOps journey, it's important to stay grounded in an understanding of what exact problem a given practice or tool solves for you. The Three Ways provide a practical framework to take the core DevOps values and effectively implement specific processes and tools in alignment with them. As you move forward in your DevOps implementation, always keep thinking about the whole system.
Ask yourself, How can I build in more feedback loops? And see how you can contribute to creating an environment of experimentation and learning.
In this course, well-known DevOps practitioners Ernest Mueller and James Wickett provide an overview of the DevOps movement, focusing on the core value of CAMS (culture, automation, measurement, and sharing). They cover the various methodologies and tools an organization can adopt to transition into DevOps, looking at both agile and lean project management principles and how old-school principles like ITIL, ITSM, and SDLC fit within DevOps.
The course concludes with a discussion of the three main tenants of DevOps—infrastructure automation, continuous delivery, and reliability engineering—as well as some additional resources and a brief look into what the future holds as organizations transition from the cloud to serverless architectures.
- What is DevOps?
- Understanding DevOps core values and principles
- Choosing DevOps tools
- Creating a positive DevOps culture
- Understanding agile and lean
- Building a continuous delivery pipeline
- Building reliable systems
- Looking into the future of DevOps