Slashdot videos: Now with more Slashdot!

View

Discuss

Share

We've improved Slashdot's video section; now you can view our video interviews, product close-ups and site visits with all the usual Slashdot options to comment, share, etc. No more walled garden! It's a work in progress -- we hope you'll check it out (Learn more about the recent updates).

An anonymous reader writes "Richard Stallman has called LLVM a terrible setback in a new mailing list exchange over GCC vs. Clang. LLVM continues to be widely used and grow in popularity for different uses, but it's under a BSD-style license rather than the GPL. RMS wrote, 'For GCC to be replaced by another technically superior compiler that defended freedom equally well would cause me some personal regret, but I would rejoice for the community's advance. 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.'"

This is exactly the problem with the GPL. Its advocates want everything to be free, and are giddy about the possibility of bringing suit against people who so much as linked to a GPL'd library and forcing their work to be GPL.

It's viral, and not in a good way. Comments like "all contribution to LLVM directly helps proprietary software as much as it helps us" show your cards. Stallman not only is an advocate for free software; he would rather harm or hamstring free software in order to damage proprietary software.

I'm not about to defend the practices of certain large corporations. But in education and medicine, institutional rules over IP forbid many people I know of from even linking to a GPL'd library. For us, if it's GPL'd then it is off limits.

Also, having a friendly non-adversarial relationship with industry is useful and will result in much broader use of your software. For most FOSS projects, exposure and reaching a critical mass of contributors is crucial. The BSD is inherently helpful in this case. The GPL just scares people off, because it asserts control over code you haven't even written just because you decided to use something that happened to have a GPL license.

So, no, Stallman, I disagree and furthermore I condemn your argument as unproductive, wrong, and unhelpful. You might have ground to stand on if LLVM were closed source but it's open - in fact, it's under a more permissive license than the GPL.

People are focusing on BSD versus GPL, but really, the thing to see here is Stallman's definition of "community". If you would ever let your software be used by for-profit interests, you are not part of the community he is speaking of, and claims to speak for. It's just that simple, no flamage or politics implied by saying that.

I've long said that people should chose a license the way they choose a screwdriver, not the way they would chose a religion. What are you trying to achieve? Want total world domination for a new protocol? Go BSD. Want to keep for-profit entities from rent-seeking based on your work? Go GPL.

It's OK to be part of Stallman's community. It's also OK to not be part of Stallman's community. It's OK for RMS to be dissapointed with people who are not part of his community. It's OK for people not part of Stallman's community to not give a rat's ass what RMS thinks.

I'll say this though, the number times I've originally dismissed one of RMS's ideas a crack-pot loony assertion, and then five years later come to see the point he was trying to make, is non-zero.

BSD, LGPL, and GPL are all free software licences. The user gets the same four freedoms in each case (use, study, modify, redistribute). But, using the BSD licence (or the LGPL) takes away an incentive to contribute to the free software project.

GCC's technical advances create a big incentive for developers who
are interested in compilers, and for companies with a commercial
interest in a good compiler existing for their platform, to
contribut to GCC - helping free software whether that's their
priority or not. With a BSD-licence project, developers can choose
to ignore GCC and fork LLVM instead, so neither GCC nor LLVM
benefits.

With GPLed software, they're free to do go anybody who can do something about it. With propriety software, there was only one place to go, and if they say "no" or they screw it up then you're fucked. Personally I wouldn't call those two situations exactly the same.

Actually, there's an interesting parallel between GPL'd code and patents. Both require the process to be public, and both assert restrictions on how those other than the original authors can use the information. In both cases, you're saying "I want the information to be readily available, but I'm putting some limitations on how this can be used, to protect the creators."

The problem with this is that unlike patents, the GPL doesn't have a sunset clause; this means that the information is tied to the will of the creators in perpetuity.

BSD on the other hand is more free in that it encourages innovation -- "what I've created is mine, what you build on it is yours, if you do build on it, give me credit for the part I did and don't plagiarize." Compared to this, GPL is "what I've created is mine, what you build on it must also be mine and must be distributed by my rules."

So, GPL is protective -- it is trying to protect the commons against people innovating something based on the commons and then using it to outcompete other code that stays in the commons. In may situations, this is worthwhile; it protects against predators.BSD however is permissive -- it is trying to provide one more step in the ladder, one more wheel that doesn't need to be created, and can be held in common. Sure, it can be abused by corporations, paedophiles, terrorists, etc., but if there are bright people who can see the value of what their predecessors did, they can continue to innovate under BSD and outcompete the predators for the good of all. Predatory use of BSD code usually only lasts one generation, because once the code has been forked, the private code doesn't get the *continued* community contributions and analysis.

There are places for both; I would hate to live in a world ruled by GPL, but would also hate to live in a world where it didn't exist.

disclaimer: I use both gcc and llvm/clang -- depending on what I'm attempting to build.

I think the "evil" of BSD is that it can always outcompete GPL, being more free, but can be abused for short-term gain in ways that GPL protects against. So GPL can never be a BSD killer (unless it has a monopoly), but BSD CAN be a GPL killer due solely to innovation.

I wonder what RMS would think of a more "business-friendly" license where a commercial entity selling software could take software that's publicly-available, modify it, and then distribute that to paying customers, but not back to the community, but where the license required them only to distribute the modified source code to those same customers, however the customers were not allowed to distribute it themselves.

RMS wouldn't like it. That's essentially what the most minimal definition of "Open Source" means -- Source access. When that company goes out of business you can't really outsource patches, you have to maintain it yourself which may be more expensive -- If you even can maintain it, the code may require a special compiler or the hardware could require code signing system that you don't have. Which is why the GPL exists as it does: To ensure that you will be able to use and improve the software you rely on even without the further input or permission of those who created it.

RMS doesn't do "Open Source Software" he does "Free Software" instead. The whole Free Software thing kicked off because he got a new OS, and his printer wouldn't work with it. He needed the driver source, and found another coder who had the same hardware and driver source, but they were required to sign a "business friendly" NDA such that that they could not pass on the code they received.

TL;DR: You don't have to "wonder what RMS would think", he created the GPL expressly to ensure customers had freedom from such "business friendly" (freedom limiting, sharing preventing) software. It's covered in his book: Free as in Freedom (2.0) [fsf.org]

- Is part of the bigger picture is that GCC doesn't make it easy to embed into an IDE?

Yes, and the fact that that is (or was) deliberate on RMS / GGC's part, therefore changing it required policy / politics not just contributing some code changes.

- If LLVM is "cleaner" under the hood so you don't need to be a compiler expert to modify / fix it, shouldn't that be a wake up call for GCC to clean up the code + architecture ?

In one sense it already has - on gnu.org there are relatively recent pages around plans for modular gcc. Unfortunately it is now years behind on this and may never catch up, as many of those interested in working on things like this will probably use CLang / LLVM rather than work on getting GCC to do the job.

There is also the issue that historically GCC architecture is deliberately unclean in order to prevent your previous (and following) suggestions. RMS does not want GCC to play any part in a toolchain/process which might have non-GPL parts, but that can't be controlled with copyright licence because simply reading / producing e.g an intermediate language does not make a derivative work. Hence GCC is locked-down technically so you can't access any of the intermediate steps. Some of it is probably historical accident of complexity and some is by design - but also by design it hasn't been cleaned up (so far).

Essentially, in order to satisfy a licencing goal that can't be achieved with a licence, GCC has been deliberately crippled.

RMS:

The GNU Project campaigns for freedom, not functionality.Sometimes freedom requires a practical sacrifice,and sometimes functionality is part of that sacrifice.

- If I want to just make a front-end for a new (programming) language why is it easier with LLVM then with GCC ?

Because LLVM IR is _much_ better documented, because that was a goal of LLVM project. For political reasons why that is, see above.

Are we really supposed to be rooting for the people who will only share if they get something in return, and will intentionally make things difficult to try to get their way? That's hardly the noble cause they make it out to be. And then when LLVM tries to be as easy to use as possible and doesn't ask for anything in return, they belittle it.

Apple's goal was instead to have a better development tool, and GCC was a roadblock. It was preventing enhancement of warnings the editor could give, real time feedback as to the code that was being written. It also had a somewhat primitive debugging experience (as much as I like GDB and have used it for many years, LLDB is better).

Apple moved to LLVM not out of any wish to harm GCC but because it was no longer possible to advance without newer and more advanced compiler technology.

Even windows wouldn't be here (or at least not on the Internet) if not for open source. BSD/SystemV is not just the base for OSX but also large parts of VMS and subsequently NT as well as the BSD TCP/IP stack and the POSIX layer within NT.

App store rules don't include any sort of restriction. Indeed there are many GPL apps on the Apple App Store.

The GPL on the other hand does make restrictions that make it difficult to put GPL software on Apple's app store. And indeed the biggest story on this was VLC, which was NOT removed by Apple, but removed by one of it's developers who believed it to be impossible to put it on the App Store because of it's GPL status. Yet look today and VLC is on the app store again.

RMS is vocally ANTI commercial software. Apple on the other hand actually release a lot of open source software themselves. Some of it even GPL.

It's a complete lie to say that Apple store TOS prohibits releasing software that is GPL. The only hostility here is from RMS and his accolytes. Thay are the ones who want it to be impossible to have GPL on the App Store. Explicitly so.

Error messages are only slightly better in clang, because GCC has improved since version 4.2, and now even clang developers themselves [llvm.org] explain that clang is better in caret positioning and colouring, which I wouldn't call being a generation ahead. See what the GCC wiki [gnu.org] says about that.

Clang is slightly faster than GCC, when compiling at the same optimization level.

Clang is written in C++ and modular, and as result of this, it is more embeddable in third party projects and it can target multiple platforms with a single executable.
Work is being done in GCC to address this but I'm talking about released code here.

But when we consider less "hip" features, GCC makes faster code (which is usually the foremost interest of a compiler's user). And GCC supports more target platforms. And GCC supports more language features (FORTRAN, OpenMP, VLAIS).