@lanodan which undocumented extensions are you talking about? Sure, the Hurd, GNU libc, GCC, etc. all extend classical Unix/C in interesting ways, and the documentation is not always perfect; but that's just from a lack of manpower, not an act of intentionally locking people in. In fact most GNU software is written in a way that *doesn't* require other GNU system components or extensions, making it very portable. This is the opposite of lock-in.

(1/2)

@lanodan he's made it very clear why he opposes clang/LLVM, and it's not on a technical basis:

"The existence of LLVM is a terrible setback for our community precisely because it is not copylefted and can be used as the basis for nonfree compilers -- so that all contribution to LLVM directly helps proprietary software as much as it helps us."

https://gcc.gnu.org/ml/gcc/2014-01/msg00247.html

(2/2)

@bugaevc
GNU: Oh no LLVM is not restrictive enough on it's license!
Also, GNU: uses a license so restrictive on GCC it's unusable in a BSD base system.

Also not on a desktop right now so can't give many links but GCC has all theses extensions on C: https://gcc.gnu.org/onlinedocs/gcc-9.2.0/gcc/C-Extensions.html
And none of the ones I looked into where documented enough to allow a reimplementation in another compiler.

@lanodan clearly, you're in a "permissive is better than copyleft" camp. That's alright, but other people have different opinions on this (namely, on what's better in the long run); that's not the reason to hate GNU or think they're hypocritical.

(1/3)

@lanodan I think copyleft is better, and (most of) my software is under GPL. That doesn't mean I call out everybody who chooses a permissive license for their projects, but I may chose not to use their software if there's a copyleft-licensed alternative that I find better (or not much worse).

(2/3)

@lanodan This quote from Linus Torvalds sums it up:

"Nobody has the right to whine about another persons choice of license. You have a choice: use it or don't. Complaining about the license to the author isn't part of it."

All those GNU C extensions seem pretty well documented to me. Not that I'm developing a C compiler...

(3/3)

@bugaevc In my experience, the C language and good documentation is not something that comes well in the same sentence. Probably because I've seen so many scientific articles in the past years that claimed to have finally understood (through very heavy mathematical models) what the C standard meant by a particular word… and then to add that well-known compilers have different interpretations of this 😕 This is not directly related to these extensions, of course, but the C language itself is pretty ill-defined per se, which doesn't help extensions.

@bugaevc @lanodan hi I have developed a C compiler and those GCC extensions are the underspecified bane of my existence

@bugaevc I think that what @lanodan tried to explain is that by the very same argumentation that you exposed at the beginning (software modularity), LLVM should be considered as a good thing: it enables you to plug any software (being proprietary or not) to the software generating the LLVM code. This is good precisely because it doesn't force the user to pick one particular software in the link, and can even choose not to use a free software for a part of the compilation chain. The magic is that this isn't even a matter of licences: a proprietary software can communicate with a free one.

In other words: interoperability is good, because it makes software chains modular.

@MartinShadok can't argue with that; it's awesome that LLVM is this modular!

The problem that Stallman sees here is that it's not only the user who can do this, it's also an upstream proprietary frontend developer, who would then distribute the resulting non-free compiler and thus deprive users of their freedom.

@bugaevc I'm sorry, it's still difficult for me to get this last argument. Sure, anyone using such a non-free compiler won't have much rights on the resulting program, but I don't get why building a non-free compiler removes writes: I would expect that this only happens if such a compiler is somehow enforced. I sure can imagine how such a compiler can be enforced, but I don't see in what aspect LLVM would be involved in this process. 😕

@MartinShadok LLVM is of course what enables the proprietary compiler writer to do this all while keeping it proprietary, this wouldn't happen with GCC or if LLVM was copylefted.

Case in point, the Objective-C frontend to GCC is only free software because Steve Jobs was obliged by GPL to release it as free software; it would've been proprietary otherwise. Then years later, Apple has sponsored LLVM development under a permissive license; guess you can see the logic.

@bugaevc One could still add a GPL endpoint to GCC from any intermediary language (SSA, for instance) and do the same. LLVM is just an intermediary language that a lot of compilers have to agree on anyway. I really wouldn't blame LLVM for enabling people to make software, be it proprietary.