4 ms·
Make should have included something like tcl, or shipped its own tcl and its own os/posix libs. It is very easy for makefiles to become tied to a particular OS/
by sitkack 9y ago
Make should have included something like tcl, or shipped its own tcl and its own os/posix libs. It is very easy for makefiles to become tied to a particular OS/Distribution/dev environment.
- chubot 9y agoGN Make 4.0 actually has Guile Scheme. This is pretty recent and I haven't seen it used yet. If anyone has seen it used, I'd be interested. https://www.gnu.org/software/make/manual/html_node/Guile-Integration.html https://www.gnu.org/software/make/manual/html_node/Guile-Int... https://jaxenter.com/gnu-make-4-0-adds-guile-output-sync-breaks-fewer-things-2-106859.html https://jaxenter.com/gnu-make-4-0-adds-guile-output-sync-bre... FWIW I wrote about how Make, shell, and awk heavily overlap in functionality here: http://www.oilshell.org/blog/2016/11/14.html http://www.oilshell.org/blog/2016/11/14.html This probably won't happen for quite a long time, but I'd like to expand my Oil shell to have the functionality of Make. On the one hand, it's kind of ironic that you're asking for Tcl, when shell is Turing complete and already such an integral part of Make (every line of the Makefile spawns /bin/sh). On the other hand, I understand that shell is a language with many sharp edges and most people dislike it. The point of Oil is to get rid of the sharp edges, and then maybe shell can take the place of Tcl/Guile. It seems a little ridiculous to write build scripts in make, shell, and guile, all of which are Turing-complete (not to mention Awk or Perl, which often show up). And I don't actually think Lisp/Scheme are very good languages for Unix-like text processing and syscalls/OS integration.
- sitkack 9y agoWhat happens when /bin/sh is dash or bash? I despise /bin/sh, it is basically PHP. There isn't a terrible amount of basic functionality that would enable makefiles to cross platform (even cross distribution would be nice). Interacting with files, file metadata, processes, exit codes, etc. Absolutely love your oilshell posts. Keep it up. I think a concatenative language would be great as the embedded logic for Make, but a Lisp would also work.
- chubot 9y agoYes that is one of the problems with Make -- /bin/sh is different on different machines, and that information appears nowhere in the Makefile. There's no way to test that the commands you're running will actually work on someone else's machine, other than by "memorizing the manual". Combining make and shell would mitigate this problem. Then you would need one binary in sync instead of two. Well, I suppose you also need "busybox", e.g. cp, mv, mkdir -p, etc. But in practice I think that is less of an issue than shell and make colliding. Thanks for the encouragement! (If you didn't catch it I linked these build system observations in a sibling comment: http://www.oilshell.org/blog/2017/05/31.html http://www.oilshell.org/blog/2017/05/31.html) I've played with concatenative languages, and read a lot about Forth. I'm not sure I see them as great for "logic". They are very elegant for certain problems, but fall down for others (IIRC the quadratic formula was a popular example.) The main kind of logic you need in Makefiles is expressing build variants -- e.g. for debug/release, internationalized builds, coverage builds, profile-directed feedback, running parameterized test suites, etc. I think that can be done fairly well with a Python-like imperative language with dicts and lists. (Some people have mentioned Bazel, and it is derived from Python and works fairly well for that.)
- stephenr 9y ago> /bin/sh is different on different machines Write portable shell scripts (or lines, in the case of a Makefile). There's some tips here: http://people.fas.harvard.edu/~lib113/reference/unix/portable_scripting.html http://people.fas.harvard.edu/~lib113/reference/unix/portabl... and of course you can refer to http://pubs.opengroup.org/onlinepubs/009695399/utilities/contents.html http://pubs.opengroup.org/onlinepubs/009695399/utilities/con...
- chubot 9y agoThat's not useful advice. That's what I mean by "memorizing the manual" (or POSIX spec). There's no way to test that the commands you're running will actually work on someone else's machine, other than by "memorizing the manual". I have an entire book on this: https://www.amazon.com/Beginning-Portable-Shell-Scripting-Professional/dp/1430210435 https://www.amazon.com/Beginning-Portable-Shell-Scripting-Pr... It goes through all the commands and common versions of Unix and which flags are likely to work, etc. Even that book admits there's a lot of folklore, because nobody has actually gone and tested things recently. Something as simple as safely writing with "echo" is a problem. You can argue that any script that uses echo $foo is incorrect (because $foo might be a flag). Conversely 'echo --' is supposed to print -- by POSIX. The only people who are likely to even attempt this are people whose full-time job it is to write shell scripts, or the authors of tools like autoconf, which must generate portable shell. autoconf shell is a good example of the anachronisms and hoops you need to jump through to support this style. Nobody else has time for that, because they have to spend their mental energy writing C and C++, not shell and make. So that's why we have pretty low standards for the quality of build systems. The tools aren't there to support writing a robust and easy-to-use build system.
- gvalkov 9y agoThe guile integration in gmake is a bit shallow, but still quite useful (here's the whole implementation [1][2]). It could also use more real-life usage examples - there's really nothing out there besides a few short snippets. As a learning experience, I wanted to implement parts of the GMSL[3] on top of guile. It looked like it could be useful to others, so I made it into its own project: the GNU Make Toolkit[4] (it's still very much a work in progress - I've put more effort into the test suite and the documentation generator than into actual functionality). [1]: http://git.savannah.gnu.org/cgit/make.git/tree/guile.c http://git.savannah.gnu.org/cgit/make.git/tree/guile.c [2]: http://git.savannah.gnu.org/cgit/make.git/tree/gmk-default.scm http://git.savannah.gnu.org/cgit/make.git/tree/gmk-default.s... [3]: http://gmsl.sourceforge.net/ http://gmsl.sourceforge.net/ [4]: https://github.com/gvalkov/gnu-make-toolkit https://github.com/gvalkov/gnu-make-toolkit
- bch 9y agoThis is where cmake missed the boat, imo. They were even using Tcl/Tk for a medical imaging project[0] when they decided they needed their own build system. Then when they needed an expressive embedded language, wrote an ad hoc one from scratch. [0] https://www.kitware.com/platforms/#itk https://www.kitware.com/platforms/#itk
- sitkack 9y agoSchaudenfreude Lol! I don't like the term "too smart for one's own good" but sometimes it applies. The CMake scripting language [0] . [0] https://cmake.org/Wiki/CMake/Language_Syntax https://cmake.org/Wiki/CMake/Language_Syntax