1. 11
  1.  

  2. 5

    not sure i agree with the argument. any programming language gives a formal record of the process. so you could just as easily have written a bash script that describes the processing necessary and then blogged about how bash provides a specification that describes what was needed.

    what make adds to something like bash is automatic memoisation. so it converts some exponential algorithms to polynomial ones. that’s a neat trick that you need sometimes when programming. and so the problem with make is that the neat trick becomes something you use even when it gets in the way. so instead of being a nice solution for certain specific problems it becomes something you’re forced constantly to deal with.

    it’s similar to the difference between dfs being a nice tool you use sometimes for graph algorithms and being forced to work in prolog.

    so i think that if you’re going to argue that make is a good too for a particular job then have to show that memoisation is critical for that job, that’s probably true for compiling large programs with complex inter-dependencies. i am not so sure it’s true for re-generating a graphic on drought.

    [i’m not sure i actually agree with the above; it just popped into my head as an argument, fully formed, and it seemed useful to write down. i think maybe it doesn’t give enough credit to how make is declarative.]

    1. 3

      One thing I really miss about make that is not present in most modern build languages is the way make “statements” are just shell commands. It makes it really easy to: a) prototype the build process in the REPL (the shell), b) integrate with other things that implement the “shell tool” contract, and c) know when you have crossed the line - if you can’t say something that’s not a small number of shell commands, it’s probably not a good fit for the Makefile.

      Rake /almost/ achieves fidelity with the shell. Psake is the closest thing I’ve seen to make in terms of shell fidelity. Leiningen is nice in that you can easily execute parts of the build in a REPL, even if it’s not made of simple shell commands and not really designed as a make replacement. All three of these have the attractive nuisance of a full language at the ready.

      It’s kind of sad that most of the newer build process tools I see go the other way and make it impossible to reproduce your build steps manually, because they use proprietary plugins and don’t work with other tools. Builds should be dirt simple.