Real DevOps Practitioners Eat Quiche
A classic article from the ’80s shows us how far the culture of software development has come.
Back in the early '80s, a funny article about computer programming hit the streets. Titled “Real Programmers Don’t Use Pascal”―parodying the bestselling Real Men Don’t Eat Quiche―it compared the characteristics of supposedly real programmers, who could code in Assembler on punch cards, to the mere quiche eaters, who had to use structured languages like Pascal.
A great deal has changed since then. For starters, computer programmers are now called “software developers”. And as for punch cards, they’re but a distant (and not-so-fond) memory for old-timers like me. We’ve also got DevOps extolling the virtues of―shock horror―collaboration and sharing.
So, does this mean software development is the just the domain of quiche-eating hipsters and that the Chuck Norris school of coding is gone forever? Well not exactly―but it’s worth taking a trip down memory lane, to revisit a few of the original article’s assertions about programming and present rebuttals from the age of DevOps.
Real programmers don't write application programs. They program right down to the base metal. Application programming is for dullards who can't do systems programming.
DevOps practitioners write all kinds of software―mobile apps, SaaS, IoT applications, games… They don’t call it the application economy for nothing. Still, good developers have insight into how their coding impacts the performance of underlying infrastructure (and vice versa) and are able to use this insight to improve performance.
Real programmers don't comment their code. If it was hard to write, it should be even harder to understand and modify….
Real programmers don't document. Documentation is for simpletons who can't read listing or the object code from the dump.
Which, of course, makes software really tough to support. Real DevOps practitioners put ego aside, preferring methods where supportability becomes a hallmark of top application design. Just because something is easier to support doesn’t make it any less pure. On the contrary, it’s the essence of high-quality software.
Real programmers don't write in COBOL. COBOL is for COmmon Business Oriented Laymen who can run neither a business nor a real program.
Much of the business world still chugs along with COBOL (even “unicorns” process payments on mainframes and use workload automation). While real DevOps practitioners might not actually code in COBOL, they’re great at unlocking value through APIs and integrating apps end-to-end. To them, enhancing the customer experience trumps scorning legacy tech.
Real programmers' programs never work right the first time. But if you throw them on the machine they can be patched into working order in a few 30-hour debugging sessions.
This is how you end up conducting 30-hour triage sessions and making your support team very, very unhappy. Unlike gung-ho programmers of yore, real DevOps practitioners remove all the constraints that result in defect-ridden software, as they continuously code, test and deploy. They’re becoming so good at it that they can push code all the way to production.
Real programmers don't like the team programming concept. Unless, of course, they are the chief programmer.
DevOps practitioners actually relish working in self-managing, empowered teams. That said, they’re pragmatic, putting more important business goals ahead of short-term project needs. And teams aren’t exclusive coders’ clubs―members can and will include systems administrators, security specialists, enterprise architects and even HR folks.
At a party, the Real Programmers are the ones in the corner talking about operating system security and how to get around it.
Not these days. DevOps practitioners bake security into all their application quiches. They regard security as essential business seasoning and liberally apply it across the development lifecycle, to increase quality. This can include folding in privileged access controls, sprinkling on fine-grained API security and serving up synthetic test data.
Real programmers don't write specs. Users should be grateful for whatever they get; they are lucky to get programs at all.
And that’s how organizations end up with so much crippling technical debt! DevOps-focused professionals accept that the vagaries of digital engagement require constant course corrections. The top ones even employ methods like requirements-based testing, with test cases and data needs established and automated right from the get-go.
Real programmers don't eat quiche. They like Twinkies, Coke and palate-scorching Szechwan food.
Well okay, maybe this still rings true. I’ve no idea why but many of my developer friends have a penchant for spicy food, candy bars and sugary beverages. Nevertheless, the ridiculousness of many of these assertions is indicative of how much the culture of software development has matured over the years.
In some cases though, we shouldn’t see the assertions as hilarious idiosyncrasies but as wake-up calls, reminding us of how far we still have to go. Even though names, functions and technologies have all changed, the persistence of parochial practices and siloed thinking remains a recipe for disaster.
Now pass me a slice of DevOps quiche.