One software freedom that Stallman does not mention is the freedom *not* to use the program because you dislike or don't want it for some reason

Free software tends to be flexible, have clear boundaries, split responsibilities, and replaceable components, thanks in part to openly defined protocols and formats

Proprietary software tends to want to lock you in into their freaking ecosystem, and even if they adopt an open standard, it's a part of an E-E-E strategy

@bugaevc Of course Stallman doesn't mention this one, GNU is basically doing vendor lock-in with their numerous poorly-documented extensions.
Also he doesn't seems to like LLVM/Clang because it allows to use some basically reversed GNU extensions outside of GCC.

@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."

gcc.gnu.org/ml/gcc/2014-01/msg

(2/2)

Follow

@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.

Sign in to participate in the conversation
Aleph

Generalistic Mastodon instance for open-minded people. Instance Mastodon généraliste pour personnes ouvertes d'esprit.