It’s probably an understatement to say that many of us were thrilled to say goodbye to 2020 last week and usher in the new year.
While 2020 wasn’t all bad, it certainly presented its fair share of challenges and changes. COVID-19 pushed engineering teams to be more distributed than ever before, transforming many things about the way we collaborate to build, deliver and manage software.
Our Director of Solution Engineering Karthik Lalithraj recently got together (virtually) with Darin Pope and Viktor Farcic from DevOps Paradox to reflect on how DevOps was affected by the events of 2020, and discuss the future of everything from containers to observability.
Below we recapped some of our favorite predictions and observations from our conversation. Be sure to check out the full webinar recording as well for more insights.
1. Static & Dynamic Analysis Will Make for a Powerful Duo
Karthik Lalithraj: Historically we’ve used static analysis tools like SonarQube that evaluate code in a contained environment – you test for a set of specific scenarios that you can predict. Particularly in light of COVID, where we are relying more on automation like this, we have to have the foresight to write better tests.
Now, dynamic code analysis has emerged on the other side of things to handle the “wild west” that is production. There’s nothing that can prepare you for production unless you actually are there. It’s not enough to test for contained scenarios you can predict, you have to be prepared for scenarios you’ve never before encountered.
Moving forward, I think static and dynamic analysis are going to make for a powerful combination. Dynamic analysis will create a feedback loop that actually informs and improves your static testing, and you’ll waste less time writing tests you don’t need while being able to test new scenarios on the fly.
2. Shift Left Initiatives Will Gain Traction – From the Top Down
Darin Pope: Everything shifting left is critical. The more we can shift left, the less people we have to have on the right-hand side. So, if in my code editor I’m writing and all of a sudden it tells me, “Hey, by the way, you just introduced a NullPointer here, or you just put in a bad check.” If I can find that out when I’m writing, it’s like, “Oh, okay, thanks. Fix it, move on.,” and then it never even gets introduced into production.
In 2021, my best guess is it’s going to pick up steam as a top-down initiative. In reality most developers do not yet take ownership of what they’re writing, so they aren’t going to add this extra work on their own.
3. Kubernetes Will Start to Disappear in 2021
Viktor Farcic: I really think Kubernetes will stop being visible. Containers are almost already there. When you deploy something to Kubernetes, theoretically you are communicating with a layer on top of containers. The containers themselves are becoming invisible. I think that that’s a trend that will continue. We will see Kubernetes disappearing in 2021. We are seeing it already, but that will become much more prominent, and when I say disappearing, it will stay where it is, we just won’t see it.
DP: Let’s think of it this way. Kubernetes is the command prompt. It’s a green screen, it’s an orange screen, for people that remember the VT100s, whereas the layer that’s coming on top of that is what we now have in UIs on our modern operating systems. But yet there’s still going to be something else coming. Maybe not in 2021, but over the next two or three years even Kubernetes will start, as Viktar was saying, it’s going to start disappearing into the background.
4. Service Mesh Adoption Will Increase
VF: I think that service meshes will increase in adoption, not necessarily because people will choose to use them, but rather because they will be forced to due to interdependencies from choosing particular tools. Basically, the more tools you’re adopting, the more you will be forced to use service mesh because it becomes an inseparable part of other solutions, (for example canary deployments).
5. Observability Becomes a First Class Citizen
it will be more than just an afterthought and it will be treated as a first class citizen and just more engineering teams will be mindful of it when releasing new code versus just slipping a monitoring tool on top of your application and hoping for the best.
KL: At the end of the day, with all the other trends we’ve discussed, you need observability, you need metrics. When I used to write code and we used to talk about CI/CD, we never relied on quality or reliability as the first class citizen. It was always there, but it was always, “You know what you’re doing,” kind of thing, right? Now, what we’ve seen is observability becoming a first class citizen.
DP: Maybe not in 2021, but at some point machine learning and AI have to be factored in. That is what will make observability that final, at least final as we understand final today, true feedback loop – self-healing based on observability. Let’s go one step further, it’s, like Dependabot, “Okay, we’re observing this, we see it’s a NullPointer. Let’s go ahead and put in a PR that fixes it then gets auto merged, tested and deployed out.” A person never touches the code that gets changed. None of that would happen without observability.
VF: A loss of observability is the stumbling block for many of the trends we talk about. One of the big reasons why people are not adopting, let’s say canary deployments, is because they don’t trust observability to have in-depth protection. And when I say trust, I don’t mean 50 people watching monitors, but trust that there is a query, an alert that will be fired when something goes wrong.
Achieving Observability: How to Address the Unknown Unknowns in Your Application
Subscribe for Post Updates