4 Things About Software Development Today That Would Surprise the Coders of the Past
By: Matthew Macdonald
Tags: Technology, Security, Software Engineering, Programming, Computer Science

Computers have now been in our lives for decades — and for most of that time, we’ve been watching them and trying to predict the future. Some changes weren’t hard to anticipate. We knew that faster, more powerful hardware would drive languages up the ladder of complexity. We predicted the way that code would infiltrate the devices around us, replacing all-in-one personal computers. And we’ve spent years anticipating the seismic shifts of virtual reality and artificial intelligence.

But other changes came as more of a surprise. Here are four things that the the pioneering programmers of the past might not have expected.

1. Programming languages are still text

In 1978, Brian Kernighan wrote this, the world’s first “Hello World” program, not knowing how famous his code would become. His starter example is preserved as a museum piece:

The first hello / WikiCommons

Today, nearly a half-century later, you’ll have no trouble recognizing the syntax of this basic C code. Which tells us something: programming languages are conservative.

Even though language churn is real, even though new APIs and frameworks spring up overnight, the mainstream shifts slowly. Object-oriented programming was invented with Simula in the 1960s. It rose to prominence with C++ in the 1990s, and — despite some worthy challengers — it’s still the dominant paradigm today. In fact, one of the most striking features of modern programming is that so many of the world’s most important languages share a similar C-inspired syntax, from C# to Swift, Dart to Go, Java to JavaScript. The more things change, the more they stay the same.

Programming luminaries have predicted for years that the way we write programs would change. We’ve been expecting natural-English languages that anyone could use, then flowchart-style visual languages that wouldn’t have any text at all, then AI-powered languages that would write themselves. Interesting experiments and niche tools aside, we’re still writing code in more or less the same way we did a generation ago.

2. Most software is cheap or free

Twenty years ago, installing a new piece of professional software meant spinning up a CD, clicking through a setup wizard, and watching one slow-moving progress bar after another. Some setup programs would cheekily suggest you use the wait to grab a coffee.

Installing software also meant shelling out serious cash, assuming you wanted a legitimate license. Consider this fine software specimen, on which an empire was built:

Microsoft Office, 25 years ago

Office 95 could be yours for a couple of hundred dollars, if you qualified for the right promotion. But a business that needed a new, full copy of the professional version would be on the hook for $599. And that was back in 1995. In inflation-adjusted dollars, buying Office 95 today would cost an eye-watering $1033. (At the time, businesses still saw it as something of a deal because it bundled together several applications in one package and underpriced its most serious competitor, Novell PerfectOffice.)

For corporate developers, the story was even more expensive. Most Microsoft developers either purchased an MSDN subscription from Microsoft (for several thousand dollars) or worked for a company that did, because of the tremendous cost of buying operating systems, development tools, database software, and other tools separately. Even the much-loathed Microsoft FrontPage was introduced with a list price of $699.

Today, that model has died. What happened? First, open-source software won the development world. It had the most enthusiastic community, some of the world’s most valuable pieces of software, and a price that was impossible to beat (free). Then it spread to the business world, where companies are now more likely to pay a metered usage cost through something like Amazon Web Services or Azure than buy seat licenses. And then it spread to the consumer world, with tech companies that give their software away and sell other people the chance to put ads in front of their audience.

Some companies still survive on a software-for-money model (Adobe comes to mind, along with many game developers). But these tend to be small or mid-sized software companies. The big players like Microsoft, Google, and Apple make increasingly small amounts from software sales. Some, like Facebook, don’t even have a way to charge for their software.

3. Desktop apps are just a special type of web app

Ever since the internet first reached the public consciousness, sometime in the early 1990s, we’ve been expecting it to change the world. As a result, many of the transformations it triggered were small surprises, even though they tore down and remade fundamental parts of our world. If you’ve been around long enough, you’ve seen the decimation of the music industry, the remaking of commerce, the death of print media, and the rise of distributed social groups for sharing news and information. All of these shifts were monumental, but none of them was unanticipated.

Another change that wasn’t too surprising was the steady erosion of desktop software in favor of web apps. Once it became possible to do something with JavaScript in a web browser — with universal compatibility and no installation process — it quickly became preferred. This process was repeated over and over again across different domains. Of course, desktop applications were still important for some capabilities and some professional niches… or were they?

Enter Electron.

With the help of Node.js, Electron created a desktop shell wrapping the client web stack (JavaScript and the DOM) and the web server stack (with some extensions for plugging into operating system APIs). If that sounds like some serious overhead — you aren’t wrong. Even worse, every Electron app gets its own distinct copy of this heavy-weight execution environment. It sounds like a bloated nightmare, but computing power and memory were already so plentiful that developers could afford the overhead. The rest is history — Electron became a professional-quality tool suitable for building applications like Atom and Visual Studio Code.

Of course, native desktop apps aren’t all dead. But Electron is thriving, and there’s a new wave of technologies coming that help developers hide desktop applications inside web applications. WebAssembly has broken the door down, leading the way to new projects like Blazor. The world has inverted.

Back in the early days of the internet, we knew that the performance gap between desktop and web would shrink. We knew that the concerns of the day (the slow interpreted nature of the JavaScript language, the extra layer of the HTML DOM, the non-native graphics API) would become less important. Some of us even knew that every type of app would eventually be made to run in a web browser. But did anyone realize that the advantages of this development model — its broad reach, and the lure of using the same technology stack everywhere — would lead us to put desktop applications inside fake, virtualized web browsers and web servers? And that the cost of that design would become almost trivial?

4. We lost the security war

In the early 2000s, we were looking at new ways of computing — and steadily increasing security risks. Untrustworthy apps could install viruses. Hackers could crash websites, and steal credit card data, documents, and emails. Identity fraud was difficult to fight.

Fast forward to today and the situation is… basically the same. Data is still stolen. Networks are still hacked. The only challenge of early-internet computer security that we’ve come close to solving is that of viruses, because we’ve created giant sandbox models for games and most consumer apps. But with universal global computing and the Internet of Things, the perimeter we need to defend has grown impossibly wide.

Security experts know that foolproof security is never possible. Instead, we strive for something called defense in depth — a layered sequence of defense measures that force attackers to thwart several systems to steal our secrets.

Defense in depth in a computer network

But here’s the problem. In the last two decades, we’ve failed to shore up the weakest link: the end user. Even though we’ve developed technologies for biometrics, we’re more likely to use facial recognition to index our Facebook pictures than to protect our data. Identity between people can’t be (practically) proved. We have facilities for encryption that we rarely use on our own data or communication. And here’s something that would stun the security expert of two-decades-ago: mysteriously, text passwords with arbitrary rules about capitalization and special characters are still a thing.

It’s true, of course, that security is an ongoing struggle, and that human nature is hard to change. But when billions of dollars can be stolen simply by asking, we’ve failed to protect our end users. And how can we explain when the world’s most technologically advanced country holds an election that’s influenced by a low-tech phishing attack?