I will admit that I am pushing 40 from the wrong side, and have been doing web development for about 20 years. In the annals of developers this makes me an old fart. And I am tempted to say things like You kids get off my lawn, even though I live in a 17th floor flat and don’t have a lawn.

In that time I have seen tech fads come and go, and have often found myself surrounded by a bunch of 22 year old developers who have all sorts of great ideas. The problem I have with this is that in general most of these kids have no idea what has already been invented in our field.

If I have seen further it is by standing on the shoulders of Giants.

Sir Issac Newton said that in a letter to Robert Hooke back in 1676. It seems that many younger programmers who should be standing on the shoulders of giants don’t even know that the giants were there and did some pretty amazing things.

A PDP-11 the hot machine of 1975

PDP-11

Back in the 1970’s people still had to build software but the computers were much slower. If you were lucky you might have a PDP-11 or VAX 11/780, both of which were great computers of the day, but still the day was the mid 70’s. A Vax might have had 1 MB of ram, and that would have been shared across many users. You can imagine that compile times could have been significant for a system like that!

But of course people still had to get work done, so how do you deal with a large compile on a very slow machine? Well the obvious method is to do less work by breaking up the work and only doing the parts you have to do.

Just the Vax Sir…

MicroVax

It turns out that the tool that was built to do this is still around, it was called Make, the current version of it is GNU Make and it ships with most Unix like systems. Make can do a lot of things but mainly what it does is follow a set of rules to produce a target image. In doing that it is very good at figuring out the minimal set of jobs that have to happen to get the result.

So it might know that to make a .o file from a .c file you run a particular compiler command, and that to build a specific library you need to have this list of .o files. So when you start make it will look at all of the .o files it needs then check to see which ones are out of date compared to the source file and compile those.

Of course make does not care what language your files are, it just knows how to build them, so one Makefile can compile code in many languages as well as do other things like run tests, copy files to remote servers and anything else you might want to do in the shell.

In addition since Make is over 40 years old (First version shipped in 1976) and has been used in huge projects it is very well debugged. You can assume that the strange corner cases that you might hit with more recent tools have been long since found and fixed.

Make works by creating a series of targets, which can depend on other targets. It then determines if things need to be rebuilt by file modification times. In modern versions you can simply paralyze builds with a flag and more.

What excites me most about a tool like make is not the specific features so much as the stability. While some of the Unix commands that make builds on may change my makefiles will still be valid 10 years from now and for a project that may be around for a long time that is important.

In addition there is the fact that since make was designed for the computers of the 1970’s and 1980’s when you run it on modern hardware it is fast. This is something that is always worth remembering.