The problem, in short, is that GCC is licensed under the GPL, a so-called "copyleft" license in that it requires that any derivative works adhere to the same license, whereas LLVM is licensed with the University of Illinois/NCSA license, a license derived from the MIT and BSD licenses, which permits users to do pretty much anything they like with the source, including "closing" their own versions rather than feeding everything back into the community. Richard Stallman sees the proprietary software companies as an "enemy" to the free software movement, but I simply don't agree.
The first question you have to ask is:
Who benefits?Stallman asserts that it is the commercial companies that benefit, because they make money off other people's backs. But is that really true? In the final analysis, is it not the end user that benefits? After all, the software that they can buy is better than otherwise possible, and because the companies can afford to sell it cheaper, having spent less work on it.
Let's look at it from a different, non-IT perspective.
Teachers have been sharing materials for years, typically without any sort of explicit license conditions. The internet has facilitated ever-easier sharing, but at the same time, it has also introduced the concept of licensing, with a massive amount of teaching material shared under a Creative Commons license. Unfortunately, the most common license is CC-NC-SA (non-commercial use only, share-alike/copyleft). The share-alike part isn't a problem, but NC definitely is in certain fields, such as language teaching. A heck of a lot of language teaching takes place outside the state school system, particularly in English teaching. Most of the English teachers in the world work for small private enterprises, teaching paying customers. That means most of the free material is not available to most of the teachers, which is madness.
After all, the end beneficiary of all teaching is the student. I'm an English teacher myself, and I don't profit by using other people's pre-prepared materials. Instead, I get time back, and that time I can use more productively in marking and individual feedback. The student gets a better lesson from me, and gets more for their money. In the end, isn't that the reason that people make free resources available?
Going back to compilers...
Every computer programmer relies on compilers, so if better compilers are available both commercially and free, isn't everyone in a better position?
Now, my line of thought may seem to be heading towards "everything should be licensed BSD style," but actually, it's not. I want to instead suggest that in all technological advancement there are two major paradigms:
Raise the floor and raise the roofWhat I mean here is fairly simple.
The floor is something that we all share, and that we can all do. In the world of physical technology, it is the accumulated portfolio of all expired patents and unpatented scientific papers.
The roof is the cutting edge; what only the best can achieve. It may be protected by patents or by trade secrets, but it presents a challenge to competitors to attempt to equal or better it with their own technology.
A BSD license establishes a new "floor" for a given software technology -- with Clang and LLVM, we now have a baseline standard, and no compiler writer has any excuse for shipping a product that is inferior. The quality of every product on the market is (in theory at least) guaranteed by a raising of the floor.
Innovation benefits from a short ceiling-floor distanceInnovation is hard. Not only do you have to come up with a good idea, but before you can raise the ceiling, you have to reach it. Imagine a newly-graduated PhD student had done his thesis on a new technique, let's say a new way to compile list structures for better runtime performance. His innovation alone is not a product that he can sell, because it is not a full compiler. Imagine there's no LLVM, and that his only option is the GPL licensed GCC,
There is a huge gap between the young doctor's floor and ceiling, and he is unable to write a whole compiler himself. He only has two choices: release the innovation for free, and start his career from scratch, or sell out to one of the big software houses that already have a complete proprietary compilation package.
This means that...
The only people who profit from a large ceiling-floor distance are the proprietary software housesThink about it.
With the Illinois/NCSA license, our young doctor can bundle his new technique into the Clang/LLVM code stack and publish a new compiler that he can sell for a modest sum immediately. He keeps all the profits.
Without permissive licenses of this sort, he would be forced to sell to one of a vanishingly small market of compiler makers, and with so few buyers, they can afford to squeeze the seller.
So it's the big guy that profits.
And what does that mean for the users? Well, we know that most compiler makers have an agenda to push. Microsoft is going to make it Windows only, and Apple will only use it in C# for Mac, and are going to keep the new feature as a Windows/Mac-only feature. Google would tie it into Go and Android's Dalvik system. A very small subset of the programming fraternity would benefit.
Meanwhile, the young doctor's own company would be selling it as part of a cross-platform stack that covers not only multiple OSes, but also multiple programming languages. A much larger part of the programming fraternity would benefit.
And it would almost certainly cost less. You'll need to license a full version of the development suite to get it from a large software house, whereas the independent vendor will be licensing a module that fits in with your existing software stack. (Which also means you get a free choice of IDEs, incidentally.)
Stallman's mistakeStallman refuses to raise the floor, because he views "proprietary software" as a single entity. He fails to recognise the difference between small independents and the major corporations, and consequently isn't looking for how the two react differently to changes in the environment.
In effect, he is failing to learn from the history of his own sphere, because the early days of Unix were almost entirely defined by floor-raising activities, with a proliferation of vendors improving and sharing the system.
The GPL prevents floor-raising, making it much harder for smaller players to gain any traction in the market, and there is nowhere that this is more evident than in the market for compilers, where buyouts and consolidation around the turn of the century dramatically reduced the number of active players in the compiler market. And at the same time, the only real free software alternative was GCC.
With luck, the rise of LLVM will breathe new life into the compiler market as a whole, and perhaps even trigger experimentation in languages. And aren't we overdue a new programming paradigm anyway?