How is computer programming different from 20 years ago

2020-01-14

Word count: 952 | Reading time≈ 5 min

Some programming concepts that were mostly theoretical 20 years ago have since made it to mainstream including many functional programming paradigms like immutability, tail recursion, lazily evaluated collections, pattern matching, first class functions and looking down upon anyone who don’t use them.
A desktop software now means a web page bundled with a browser.
Object-Oriented Programming (OOP) has lost a lot of street credibility although it’s still probably the most popular programming model. New trait-based programming models are more pervasive in modern languages like Go, Rust and Swift. Composition is preferred over inheritance.
You are not officially considered a programmer anymore until you attend a $2K conference and share a selfie from there.
Because of the immense proliferation of multi-processor CPUs, parallel programming is now usually supported at the programming language level rather than primitive OS calls of 20 years ago. It brought in asynchronous programming primitives (async/await), parallel coroutines like goroutines in Go language or channels in D, composability semantics like observables with reactive programming.
A pixel is no longer a relevant unit of measurement.
Garbage collection has become the common way of safe programming but newer safety models are also emerging like lifetime semantics of Rust and snarky jokes in code reviews.
3 billion devices run Java. That number hasn’t changed in the last 10 years though.
A package management ecosystem is essential for programming languages now. People simply don’t want to go through the hassle of finding, downloading and installing libraries anymore. 20 years ago we used to visit web sites, downloaded zip files, copied them to correct locations, added them to the paths in the build configuration and prayed that they worked.
Being a software development team now involves all team members performing a mysterious ritual of standing up together for 15 minutes in the morning and drawing occult symbols with post-its.
Language tooling is richer today. A programming language was usually a compiler and perhaps a debugger. Today, they usually come with the linter, source code formatter, template creators, self-update ability and a list of arguments that you can use in a debate against the competing language.
Even programming languages took a side on the debate on Tabs vs Spaces.
Adobe Flash, which was the only way to provide some smooth interaction on the web, no longer exists, thankfully. Now we have to develop on three different platforms with entirely different programming models in order to provide the same level of interaction.
IDEs and the programming languages are getting more and more distant from each other. 20 years ago an IDE was specifically developed for a single language, like Eclipse for Java, Visual Basic, Delphi for Pascal etc. Now, we have text editors like VS Code that can support any programming language with IDE like features.
Code must run behind at least three levels of virtualization now. Code that runs on bare metal is unnecessarily performant.
Cross-platform development is now a standard because of wide variety of architectures like mobile devices, cloud servers, embedded IoT systems. It was almost exclusively PCs 20 years ago.
Running your code locally is something you rarely do.
Documentation is always online and it’s called Google. No such thing as offline documentation anymore. Even if there is, nobody knows about it.
A tutorial isn’t really helpful if it’s not a video recording that takes orders of magnitude longer to understand than its text.
There is StackOverflow which simply didn’t exist back then. Asking a programming question involved talking to your colleagues.
People develop software on Macs.
Internet connectivity is the norm and being offline is an exception which is the opposite of how it was back then.
Security is something we have to think about now.
Mobile devices can now show regular web pages, so no need to create a separate WAP page on a separate subdomain anymore. We create mobile pages on separate subdomains instead.
We open source everything by default except the code that would really embarass us.
There are many more talented women, people of color and LGBT in the industry now, thanks to everyone who fought against discrimination. I still can’t say we’re there in terms of equality but we are much better.
Getting hacked is a regular occurence. Losing all your user data usually circumvented by writing a blog post that recommends changing passwords and that’s pretty much it. Apology isn’t required.
Working as a programmer remotely is easier than ever thanks to the new technologies like video conferencing, ubiquitous internet access and Keurigs.
We don’t use IRC for communication anymore. We prefer a bloated version called Slack because we just didn’t want to type in a server address.
We run programs on graphics cards now.
Your project has no business value today unless it includes blockchain and AI, although a centralized and rule-based version would be much faster and more efficient.
For some reason, one gigabyte is now insufficient storage space.
Because of side-channel attacks we can’t even trust the physical processor anymore.
A significant portion of programming is now done on the foosball table.
Since we have much faster CPUs now, numerical calculations are done in Python which is much slower than Fortran. So numerical calculations basically take the same amount of time as they did 20 years ago.
Creating a new programming language or even creating a new hardware is a common hobby.
Unit testing has emerged as a hype and like every useful thing, its benefits were overestimated and it has inevitably turned into a religion.
Storing passwords in plaintext is now frowned upon, but we do it anyway.