The beginning of my programming journey

Many years ago when I started out on my programming journey I would spend most of my coding day developing software. That might seem like a strange thing to say to a programmer who spends most of the day coding, but it has not always been that way. Coding an ICL 1904 (or 2900 series) all I had to do was write some code, surround it with a control language to define the environment I needed and the computer took care of the rest. Ok, to be honest, the resources available were extremely limited; printers, punch and magnetic tape and very expensive discs but they were there at my beck and call. I know in reality behind the scenes there was a Computer Operator loading cards, collecting output, lugging about huge disk packs and tapes and keeping the computer running but this was not my concern. Oh, and someone maintained the air conditioning. Lots of air conditioning. As always in our industry things change and my mainframe programming days did not last long.

I signed up for a microprocessor course in my second year of university and discovered I had a computer all of my own. The whole thing. Development tools were a little limited but what the heck it was a computer and I didn’t share it with anyone. No one else was required, not even an air conditioning maintenance person. This was clearly the future. Over the next 10 or so years Personal Computers got bigger and I became my own Computer Operator. If I wanted a database I installed it. A memory upgrade? Just plug it in. New video card? Hours of endless fun with video drivers. Need a backup? Backing up a 20MB disk to 360KB floppies took far too long so we just saved the occasional file instead. I had complete control of my computing environment and plenty of time in hand to program. It was a good time to be a programmer.

PC’s became a problem

It didn’t last. Over time the restricted environment of PC’s became a problem. The downside to personal computers was that they were personal. Sharing data or programs was hard. Networking computers was even harder. As organisations addressed these issues we saw the arrival of larger centralised network servers with System Administrators. As a software developer, I could have learned the skills of the SysAdmin but access was tightly controlled. The freedom of personal computing was gone in a flash to be replaced by rules, restrictions, forms and process. It was frustrating not to have the resources I needed under my control as and when required. Deployment of systems required many meetings and careful coordination. Live services had teams of people to operate and maintain the servers and kept programmers at arms-length in case they might break something.

The internet happened

Then the internet happened. The backend became the front-end as the Web Server became the primary tool of my trade. A window of opportunity opened and once again one box ran everything. I quickly adapted and learnt the SysAdmin skills required. This freedom was even shorter-lived as it wasn’t long before one server wasn’t sufficient. We needed database clusters, firewalls, VPNs and backups. I discovered that being a SysAdmin for these systems was a full-time job! While we had control of the resources we found so much time was being consumed commissioning and operating the boxes. It was hard to find time to write the programs we were being paid to deliver or to find the money to hire the people to do all the extra tasks.

If it had only been one set of servers it would have been one thing, however, every customer wanted their own. On top of that we needed more systems for testing. Building new computing environments was getting very complicated. We added writing long and convoluted configuration scripts to our list of jobs. These were complex and fragile but made life a little easier. We dallied with Chef and Puppet but just didn’t have the time or inclination to become masters of these. The rise of virtual servers and cloud computing allowed us to reduce our running costs but did nothing to reduce their complexity.

Then along came Docker

Then sometime in 2014 I stumbled across Docker. I found that I could build and install our code in a few simple lines of configuration. I could replicate a server farm and database cluster on my desktop with just a few keystrokes. This was promising. It wasn’t long before Docker was tightly integrated into our development process. We debugged using Docker, we built our own Docker containers and easily deployed them into the cloud. The speed and simplicity was awesome. One toolchain for development and live environments. We could easily run multiple services on one virtual server. The economics of this was even better. We freed up gigabytes of disk space being consumed by virtual machine images.

Docker saves SO much time

The time savings of using Docker have been huge. Our small team of programmers spends most of their day programming while, at the same time we manage and operate complex system deployments. We can look back with nostalgia to those days when too much time was spent deploying and managing the software and comparatively little time was spent writing it.

With Docker and cloud computing as a programmer, I can once again focus my time on developing software with control over the computing resource I need. This time there are more resources at my fingertips and they are better and easier to use than ever before.

Postscript

The first computer I programmed was an ICL 1904 running the George 3 operating system. If you want to connect with the computer history you can run the George 3 operating system on a Raspberry Pi (https://www.rs-online.com/designspark/running-george-3-on-a-raspberry-pi)

Why I love Docker and other programmers should too