What moved the needle?

The most impactful changes from forty years of software development trends

When I started developing software, I was writing in BASIC on a Commodore PET. I edited them by typing in the line number, followed by code, followed by enter. When I was done working, I saved the files to a cassette tape and stuck it in a box.

Which fads had the most lasting impact, and which ones have been clear successes? I may not have all the answers, but I can offer the opinion of someone who has

“Object Oriented Programming” was a key fad throughout the 1980s. It introduced lots of concepts including polymorphism, inheritance, constructors, destructors, and many others.

With the ability to hide code, it was now possible to create contracts. Every developer was now free to expose only the methods they trusted to the outside world, and to hide everything else as an “implementation detail” that could be changed when optimization was needed.

Today, we may sometimes forego objects in favor of lambdas, procedural code, and functors. But we still value the concept of contracts, and code wrapped in a contract will forever be much easier to develop than one with spaghetti bindings.

This was radical! We had grown up using whatever editor was at hand. Compiling and running a program was done through command line instructions that had nothing to do with the editor. The editor had no idea what code we were writing — so how could it help us?

Once we had successfully adopted the concept of a programmer-specific editor, we gradually gained many more fantastic tools. Features like integrated debugging, project settings, autocomplete, and warnings displayed while you write code.

But other parts of Java actually changed the world. The concept of garbage collection, previously an academic research concept, would take over virtually all programming languages except for those requiring extreme optimization.

With the elimination of most memory errors and the introduction of bounds checking, programming became less dangerous and companies responded by writing their own business logic in-house, a task that had previously been outsourced.

Of growing importance today is the concept of bytecode. Java claimed that a developer could write “one application that could run on any computer” — a ludicrous claim at the time that was still true in 2005, when most Java runtimes had so many quirks that you couldn’t upgrade without serious work.

Designing a robust and performant data structure for your application is hard. It’s even harder when you had to write your own linked-lists, hashes, trees, and vectors. Programmers had to write their own persistence logic as well: binary file formats that supported versioning were hard!

The concept of SQL had been around since the late 1970s but it became an overnight success in the mid-1990s simply because it offered a standard persistence format that everyone could agree upon. When your corporate data was stored in an SQL database, anyone could develop for it.

Compared to the new generation of SQL-backed applications, custom file formats were virtually unusable. Corporations suddenly demanded the ability to export everything into SQL: data warehouses took over, and everyone could write a corporate application that answered core business questions.

Today it’s hard to imagine a project that does not have automated tests, and harder still to handle a project that doesn’t have continuous testing. Any manager who still tests their products manually should be ashamed of themselves; the quality improvements to be gained are astronomical.

Code reuse has been a challenge for decades. In the 1980s we would share floppy disks with the latest copy of a “tools.pas” library every time we made an improvement; some organizations published dumps of sourcecode on FTP servers, and others made use of public version control systems to allow customers to download copies.

I’m sure I’ve overlooked many fantastic developments in the history of programming, but these were the techniques and developments that made the greatest difference to me personally. I’ve intentionally left out tools that didn’t help: things like Gantt charts, J2EE, Object-relational libraries, COM components, scrum/agile, virtual servers, and others.

What’s helped you to write better software?

Related posts:

You may hate this article because it is one of my 5 minute articles. Actually this is my second one. Actually I think i am going to give myself 7 minutes just like the previous article. Maybe you may…

HARA introduced itself to blockchain enthusiasts and entrepreneurs at the Japan Blockchain Conference (JBC), which was held in Tokyo on the 26th and 27th of June. The JBC is one of the largest…

Freshii is launching a kale Caesar salad, a limited-edition menu item reflecting Freshii’s take on the classic Caesar. The kale Caesar starts with a base of kale, quinoa, protein-rich hemp seeds and…