Comment by SomeCallMeTim | Hacker News Reader

Comment by SomeCallMeTim | Hacker News Reader

Parent Full thread

* As pointed out by another commenter, Apple switched away from GCC as the default to CLANG.

* Microsoft is supporting CLANG.

* Android switched from GCC default to CLANG default.

* The CLANG development community, combined with the LLVM development community, are both extremely robust.

* GCC used to have full time commercial developer contributors working for Google and Apple and other large companies; most such companies have migrated almost entirely to CLANG/LLVM support.

* Because of better management and the army of full time commercial developers contributing to it, CLANG is better in practically every conceivable way at this point than GCC. If GCC weren't GPL, CLANG would likely be (at most) a fork of GCC, and may have been merged back into trunk by now (this happened to GCC once before).

CLANG is also an excellent example of how a completely permissive license can be sufficient to encourage big companies to contribute their changes back to the commons. All of the GPL fearmongering would have you believe that CLANG couldn't exist, and yet it thrives.

And printer drivers are still almost all proprietary [1]. So GPL didn't even achieve the objective that inspired it.

GPL did prove that open source CAN work, and it jumpstarted the open source movement. But its time has past; enough people understand the benefits of contributing to open source that the coercion is no longer necessary, and in fact is harmful.

[1] Some printer drivers have been reverse-engineered for Linux, certainly. But modern printers frequently leave so much processing for the host that their drivers are nontrivial, and even when there exists "free" drivers for Linux, they pale in comparison feature-wise to the proprietary drivers. I'm sure there are exceptions.

LLVM was not created as reaction against the licensing model of GCC. It was created as a research project exploring: "transparent, lifelong program analysis and transformation for arbitrary programs."[1] GCC and other compilers were not setup to do this. They needed to build an intermediate representation of a kind that was highly unusual for the time. That is where it originated, as pure research. Trying to build a better mouse trap. Not to become a GCC competitor. It did become one because it turned out they had some rather good ideas!

The GPL is not harmful and I encourage you to utilize it when appropriate for it protects you (the original author) and your target users far more than BSD or other similar licenses.

[1] http://llvm.org/pubs/2004-01-30-CGO-LLVM.html Read full paper not just the abstract to get the full picture.

> It was created as a research project exploring: "transparent, lifelong program analysis and transformation for arbitrary programs."[1] GCC and other compilers were not setup to do this.

gcc was in fact set up to explicitly not be able to do this.

The developers of gcc made understanding the intermediate forms as well as creating plugins as hard as possible specifically so that you couldn't get around the GPL.

clang a direct result of attempting to coerce people with real money with the GPL.

> > It was created as a research project exploring: "transparent, lifelong program analysis and transformation for arbitrary programs."[1] GCC and other compilers were not setup to do this.

> gcc was in fact set up to explicitly not be able to do this.

GCC was originally very difficult to integrate with so that non-free programs could not be built on top of it. However, the creation of LLVM does not reduce to: "GCC was difficult to work with so we made this." There had been many attempts to make "Universal Compiler IRs". These attempts had not gone well. LLVM instead chose to do something at a unique level of abstraction that wasn't good for everything but was very good for its particular niche. Once again, read the paper, LLVM really wasn't created as a reaction against GCC.

I feel like the GPL-ness of gcc was less material than the fact that it's developers were afraid of closed source frontends benefiting from their work, and obfuscating the front end so that it was hard to use without pulling in the rest of the codebase.

And the reason I switched was because Clang had better error messages.

c.f. Stallman squashing the exportation of ASTs from gcc for use in emacs earlier this year.

Like other commenters, I think GPL had little to do with switch to Clang/LLVM. I liked it for its better, versatile design with a community turning it into the program analysis/transformation baseline to beat them all (minus Semantic Design stuff maybe). However, I think your overall point is supported by the fact that many virtualization solutions in embedded space are marketing GPL isolation as a benefit worth buying them. They probably wouldn't be saying it unless they had lots of customers talking about that problem.

Interesting point about the virtualization. MANY companies are scared of GPL, for certain.

Thinking about Clang, its better design didn't evolve in a vacuum. Clang was primarily developed by Apple [1] so that they would have (with LLVM) a full compiler toolchain that didn't include GPL code (and as others have mentioned, Clang is designed to integrate with editors for parsing, while GCC is explicitly designed to be HARD to integrate that way so that it can't be snuck into a proprietary project).

YOUR choice to change to Clang may not have been about licensing, but licensing and design choices in support of that license philosophy are what caused Clang to exist.

[1] https://en.wikipedia.org/wiki/Clang

This gives the worrying possibiltiy that Apple can benefit from an open source Clang and LLVM now, and in future can make thecomponents required to compile code to their platforms (mainly thinking iOS) proprietary.

They're already moving to encourage / require iOS devs to ship them LLVM IR code - the most logical reason for this is so that they can keep the last part of compilation entirely proprietary in future, taking further freedoms from users and developers.

They design and fab their own ARM chips already, so this is plausible.

Exactly. They did that sort of thing with Mac OS and iOS on Darwin. They're doing it with Clang. They always do it. It's how they make billions of dollars. Not sure why you worry whether a particular company might scheme: simply don't buy their stuff.

See how that works? And despite Google's BS, I have plenty of ways to keep Android devices largely under my control. On that side of the fence, people stopped worrying and started modding en masse. :)

Further, mobile security vendors such as OK Labs w/ OKL4 let us isolate that mess while programming directly on the kernel or a custom runtime (think MirageOS for mobile). So, we have plenty of options because we aligned with a company doing open-source mobile with little lock-in. Align with closed-source and lock-in loving companies then you get what you had coming. ;)

They also of course did the opposite with Swift - created a proprietary front end.

My choice was about licensing and design but 90+% design given GCC was a pain to work with. Your link shows two paragraphs of text talking about design issues with one sentence on licensing. So, it seems Apple's justifications were more similar to my own than different.

The best part is that so many have jumped on the LLVM bandwagon. There's even a formal semantics to get formal verification work going. Mainstream coders, tool developers, and high assurance people all under the same roof contributing a bit to the same tool. Lots of potential there.

FreeBSD has switched from GCC to clang as well.

Thanks for writing this up, you make some excellent points. Could you comment on why the BSD's (FreeBSD / OpenBSD / NetBSD) has so far not made inroads against Linux which happens to be GPL2 licensed?

First of all, BSD, in the form of OS X and iOS, is more than holding its own.

On the desktop, I believe that BSD was (a) hamstrung by the AT&T / BSDI lawsuit at a critical time and (b) suffered from fragmentation brought about more by incompatible forceful personalities than by technical issues.

Please stop this bizarre insistence that OS X = BSD. Different kernel, radically different OS overall, not open sourced.

Still shares some userland, but this is irrelevant.

For a true picture, look at how well their open sourced Darwin OS project is doing in terms of update and support.

Apple gutted the FreeBSD core team back in the 90s, hiring them all away.

Different kernel

But fairly similar userland.

Still shares some userland, but this is irrelevant.

I would say that for most people, the API matters far more than the kernel implementing it.

not open sourced

http://www.opensource.apple.com has the kernel sources under "xnu". I don't think that substantially less is open sourced than e.g. for Android.

look at how well their open sourced Darwin OS project is doing in terms of update and support

The updates are fairly current (10.10.1 corresponds to the version of OS X shipped last fall), though there doesn't seem to be a very large community building on it.

> First of all, BSD, in the form of OS X and iOS, is more than holding its own.

Those are proprietary forms. I think we were talking about whether the decision to be BSD-licensed has been good for the health and contribution of the *BSD projects that OS X and iOS originated from. Then we can draw a conclusion (but hopefully after gathering more data) on whether releasing your codebase GPL or BSD is more likely to lead to long-term health for that open source codebase.

But was GCC ever top of the heap, compared to stuff like Intel's compiler and Microsoft VC++?

http://blog.pgaddict.com/posts/postgresql-performance-with-g...

https://www.phoronix.com/scan.php?page=article&item=clang-gc...

Show gcc and clang to be broadly competitive without a clear winner in terms of speed of execution.

Reply on news.ycombinator.com