My programming habits

i.e. why I do not use make

My programming habits formed well before Unix.
My first (Fortran) programs were written (on a card punch) for an Univac 1100 and then for an IBM 360 machine (I used the latter also a lot via Electric).
Therefore I got well acquainted with the classical C-L-G phases of programming although perhaps the latter tended to be slightly blurred on the IBM VM/CMS systems, where one usually ran a program from the relocatable via the LOAD program (START command

For those which do not have clear ideas on it

Quite soon I met the need for libraries, both because I had to use libraries written by others (for graphics, for accessing satellite data), and because I'm lazy and tend to re-use software I've already written (I do use code I wrote more than 15 years ago, and I regularly use one routine, Bevington's CURFIT, which was published in 1969).

Therefore, at the time I worked on HP-RTE, I devised the following model which I still find valid and applicable :

I enforced the above model implementing it via a number of scripts, the current incarnation of which exists for VAX VMS (which I do not use any more) and for several flavours of Unix (Sun, Ultrix, OSF/1 aka DU aka Tru64). It is out of the scope to give a full description of this Real Programmer Tool (I have computer readable documentation, but on an offline machine ... if anybody is really interested can contact me, for the documentation or a copy of the scripts ... but I suggest one tries to write one's own set). Anyhow all is done with a few commands : With respect to the above model, I have introduced an additional detail, i.e. the handling of include files. Since the INCLUDE statement is intrinsically unportable because it makes reference to system dependent file names (or actually, directory names), I use in my programs exclusively pathless include files of the form
I collate all include files in a specific directory, the incdir, and let my scripts hide all system specific arrangements to locate it and deal with it.

Given that I find myself at ease with the above arrangement, why should I use make ? What will make give me more ? In theory, dependencies ! The possibility to recompile and relink all items affected by an update to a specific item. However they way I see dependencies in my model is the following : However make does not use that model. If I edit subroutine suba but not subroutine subb, it will update the library in which both are contained, and recompile (since there are no objects around) and relink all programs which call any subroutine in that library : those who call suba, as well as those who call subb or any other routine !
Also I found that the behaviour of make is system dependent.

A colleague of mine developed a tool to create and manage makefiles using my model. They incorporate a modified version of a script of mine, derived from the Real Programmer Tool, to find dependencies. These script relies on the use of a loader map which is not created under all operating systems (it is under DU and it was under Ultrix).
At the time such tool (a collection of shell scripts) was created, it contained almost as many lines of shell code, as source code lines in the project for which it was created !