Developers keep the world turning. Give them some love.
Life is full of frustrations for creators and developers. It hardly seems fair that if something works beautifully nobody notices it, but if it goes wrong, then it hits the headlines.
This effect can be seen all over the place. Ever bought a subwoofer? Unless you're into drum and bass, subwoofers should be invisible (inaudible, to be precise). What's the point if you can't hear them? Well, you actually can hear them, but properly set up, the effect won't stand out: it will just make your HiFi speakers sound a little bit better, with maybe a subtle extra octave on the bass.
Ever marvelled at CGI visual effects? I'm sure we all have. But we've probably not marvelled at the best examples, because they're so believable that we don't even realise they're there. What we see is a blue sky with fluffy white clouds and not the back wall of a studio lot, or we see an impressive-looking country house when in reality there's only a front door and its surroundings. The rest is all green screen, but we don't know that.
And it's the same with software. When you boot your computer up, you never think "whoever wrote the software that makes my computer wake up is a genius". Nor does it occur to you when you sit down to watch a two and a half-hour Netflix film on your laptop that you're only doing that because someone wrote some very slick software.
But if you try to load another film and all you get is a message about not being able to reach the server - then, suddenly, someone gets the blame.
Most of the time, software that we use both in our daily lives and professionally, "just works". Even if we're driving it close to the edge of its performance envelope, we take for granted that we're going to be able to do the wide variety of computing tasks that make up our typical day.
Like every aspect of technology, software has evolved continuously. Many of the programming languages that we've heard of date back 30 years or more, but changes in hardware - especially in processors - have driven software to new heights of performance, and to some extent, new levels of reliability.
You could be forgiven for thinking that it should be the other way round, because software is getting more complicated. That's certainly true, and to add to that complexity is the fact that almost every electronic devices runs some kind of software, and that these devices frequently communicate with others over Bluetooth, Ethernet, or via some kind of internet connection. Each time two or more devices "talk" to each other, they do so via a software interface, which is ultimately another computer program that can go wrong.
Software techniques have moved on from the days when there was a spaghetti bolognese of code that was hard to maintain and even harder to fix. instead, today, we typically have layers, containers and microservices. What's behind all of these is the idea that if you build code in increasingly small modules that talk via standard interfaces, then if one module breaks, it won't bring the rest of the pile tumbling down. The internet is built around these conceptual layers, and software that runs in the cloud often uses "Kubernetes", a method of containerising software and making it easy to maintain and update and "Microservices", which are tiny units of software that only have a single function. Each microservice talks to others through an API - a standardised interface that stipulates what can and can't pass between modules.
Not only does this type of thinking make it easier to integrate software from different sources into a larger, more functional system, but it makes it more reliable and easier to fix too. It limits the damage a "bad" piece of software can wreak, and makes it simpler to replace with a new module. To see how this works, think of a camera lens system. As long as a new lens conforms to the lens mount standard, it should work well. It doesn't matter that the camera designers have never seen the lens before: the specification of the lens mount guarantees that it will function correctly.
So modern software techniques have made it feasible to design increasingly sophisticated and clever software. But it still doesn't make it easy. There is always pressure to push at the limits of software and the underlying hardware, and no more so than with software that plays, records, edits and processes digital media.
Digital media is extraordinarily demanding on developer, but It's not quite like the old days when a PC struggled to make anything more than a single bleep. These 1980s computers were essentially hacked to play any kind of media, with full-length cards to accelerate audio and to attach media drives that were tiny compared to today's multi-terabyte monsters.
"Class Compliance" means that if you plug a class compliant device into a computer, you know it's likely to work without additional software. But if you need more than just a basic functionality then you're into driver hell. And it's often not the drivers that cause problems, it's operating system updates that make perfectly good drivers obsolete.
Modern software is amazing
Modern software is almost miraculous in its scope, ambition and reliability. It's brought us smartphones and slim, powerful laptops that sip battery power. Today, we can edit 8K video on a computer that we can fit in a shoulder bag. We can do this because some talented people designed the software to make it happen.
As long as it all works, we don't think about these designers and engineers. We never think of software as an incredibly sophisticated machine that somebody made.
And we rarely consider that when it goes wrong, a team of developers will probably have to stay up all night to fix it.
Developers know that this is all part of the job. They willingly fix software when it breaks. But I'm pretty sure that no-one ever calls a support line to say "this software just works beautifully day after day", or "this application made a documentary that's now on Netflix". Or even "I don't know what I'd do without this app".
Spare a thought for developers who are fed with a diet of problems, and yet still come up with software that gives us superpowers.