3 ms·
This is a poorly-thought-out screed by longtime BSD hacker Poul-Henning Kamp, a.k.a., someone who should freaking know better. Autoconf doesn't exist because "
by bitwize 3y ago
This is a poorly-thought-out screed by longtime BSD hacker Poul-Henning Kamp, a.k.a., someone who should freaking know better.
Autoconf doesn't exist because "the bazaar" is full of lazy incompetents and only cathedrals have halfway decent design. It comes from the bad old days when "open" meant "spec documents are available under RAND terms" and had little to do with what we now call open source. Unix had splintered into lots of different idiosyncratic systems, each with its own configuration, and the GNU stuff had to run on all of them. Autoconf provided a portable way to paper over all those differences.
The same with libtool. The Unix splintering had already happened when shared libs became relevant for Unix. There wasn't even agreement among the various vendors on how to implement shared libs! For example, how do you resolve the fact that a dynamic/shared library could be loaded anywhere into a process's address space, making absolute pointers inside the library invalid? There were two main schools of thought:
* when linking the library, replace all exported pointers with placeholder values. Then when the dynamic linker loads the library, it swizzles the placeholder values back into pointers. (Windows)
* use position-independent code, taking advantage of relative jumps, calls, and data accesses to create an object file that can be loaded anywhere. (ELF)
I've seen some half-measures as well:
* give each library a fixed address where it's loaded every time (Linux a.out)
* punt on symbol resolution; hand the programmer a base address and have them call into the library at fixed offsets from the base (AmigaOS through 3.x)
Each of the implementation strategies for shared libs required a different constellation of compiler and linker flags. Again, libtool papered over these and made it tractable to write shared libs for a variety of operating systems. It is true that these days, compiling with 'gcc -fPIC' and linking with 'gcc -shared' will probably do what you want. But that assumes a modern enough OS and toolchain, something that GNU couldn't and still cannot in some cases necessarily assume.
The purpose of both these programs is to portably solve problems that were created by multiple, competing cathedrals. I don't like Autoconf or Libtool. They're unholy messes. But they're largely that way out of necessity considering the problems they solve, problems which would otherwise be nigh-intractable -- not because their developers were lazy or incompetent.
And no, Meson does not solve the same problem, it punts on working on any OS that's insufficiently modern.
The neat thing about the open source bazaar is that it can produce reference implementations for things everybody agrees should be in the finished product, reducing the friction of competing implementations. An example is the 86open consortium, an effort by various proprietary x86 Unix vendors (mainly BSDi, Sun, and SCO) to agree on a single binary standard for x86 Unixes. Well, the vendors got together fully expecting to get into the weeds with meetings and committees and stuff... but what they found was all their products had Linux/ELF kernel personalities already built in. So they declared Linux/ELF to be the binary standard and disbanded the 86open initiative!
- Pinus 3y agoAutotools was a perfectly reasonable way of solving 1993 problems with 1993 tools. Whether it still makes any sense in 2023 a different matter... Having said that, given the choice between a non-working autoconf build scheme, and a non-working cmake build scheme, I prefer the former, but that may just be me getting old and lazy. Obviously, a working setup of anything would be much preferrable, but that seems like hopeless case if one is using anything other than the most popular Linux distro at the moment...
- dig1 3y ago> Whether it still makes any sense in 2023 a different matter... IMHO, it still makes sense in 2023. Suppose you want to ship & build your program on the latest Ubuntu, OpenWRT, 5 year old NetBSD or whatever SunOS user might be running in his basement. In that case, Autotools is your only bet without you having to run all those OSes to test if your programs build correctly. If you scan through GitHub, most projects support only the "latest" whatever because modern build systems aren't capable of anything else without significant workarounds. And you get that for free with a few autoconf & automake expressions. They are not perfect, but the problem they are solving is nasty.
- cmrdporcupine 3y agoExactly this. While I'm not a huge fan of the "Bazaar" as a development model, I'm even more terrified of the "Cathedral" and/or anybody who has an idea that there's one-true-way to do things (and it's always theirs and only theirs). Behind that scary door is the war of architects and their egos, splintering half-completed standards, and nightmares from the past like CORBA etc -- maybe-decent on paper, but good luck ever finding an open and usable and actual quality, working implementation. What we need is to develop consensus on how to do things, and that, unfortunately, is messy, takes time, and involves people compromising all over the place. And I'm not convinced that committees are the right instrument for that either. The essay's slagging of the .com era is funny to me as well; because I lived through that era and was absolutely one of the messy green hackers/devs that he is complaining about. Funny thing is though that things shipped, still, and it led to a lot of people being able to make web pages, write code, and get themselves out on the Internet who hadn't had that privilege before. And it wasn't the quality of the software that caused the .com implosion after, it was the quality of the business plans. And I also saw what came after, the kind of reaction to the .com chaos; it was all J2EE and EJBs and big enterprise application servers, and I never worked in a single shop where that actually led to anything quality and saw more than one where a team that was doing Perl+CGI+Apache ate itself by rewriting everything "the right way." A few years later, the trend swung back the other way; Ruby on Rails, web2.0 etc. etc. Software development is messy. That's just how it is.