So first, I need to set the scene of my experience because this is something that at the start of my career, I really wish I had. It would have solved several issues that I kind of battled through. So my first developer job, which was 2011, I was a bit of a rarity because I worked on a tiny team. We had to do everything. So we were developers, we were support analysts, we were dealing with outage situations, user acceptance testing, requirements gathering. I pretty much did everything and wore so many different hats.
And then later, it was only really when we ended up offloading things like some testing and some support where I got to work with individuals and actually learn some best practices rather than muddling along as I went. But then when I moved roles, I found that actually that prior experience is very, very rare indeed. In fact, the normal situation, which I still hear from speaking to many DevOps engineers and SREs is that it's a bit more like a game of Rock'em Sock'em Robots when it comes to developers and support kind of almost at loggerheads sometimes with the conflicting ideas. And quite often there's testers maybe in the background, unless we've ended up with the situation where developers are responsible for their own testing and validation.
Now, shifting left is not a new thing. And when I first heard about this, I thought, this is a great idea. This will lead to perhaps a little bit more harmony in that situation. Perhaps, you know, with the emergence of common practices, we can work together. Myself and other devs can learn more about how to build more maintainable applications. You know, maybe everything will be all great. And instead, I've seen something a little bit more different happen where actually in some regards, we've got all these great additional disciplines. If you think about SREs, DevOps engineers, there we've got prompt engineers, all these people that are able to dive deep into topics and show off expertise. But we still don't necessarily collaborate together very well. And this can still lead to a very fractured experience. And there's several reasons for that. The first is that particularly in large organizations, those existing silos still persist. And in fact, DevOps is often adopted out of an existing production management function, meaning that it doesn't really align with developers because they're still having those kind of cultural mishmashes and barriers in place. Our empathy isn't great. We're not really great at trying to understand the other side of it, because SRE activities, ML engineer activities, developer activities, these things are all surprisingly different, to the extent where even the priorities that we have as teams is different and can be struggled to align together too. Sometimes quality is a bit of an afterthought. Developers and the notion of shifting left means that we've had to learn all sorts of wacky things around security, best practices, error handling, monitoring diagnostics. And actually, we need more help because otherwise we end up just covering over the cracks. But the biggest problem, to be honest, is that we're using very different toolkits, which sometimes makes sense for the role that we're doing. But when we're using the same different tools to achieve the same ends, it doesn't really make sense anymore.
Comments