FreeBSD Is No Longer Building GCC By Default
phoronix.com
phoronix.com
They also haven't pushed it as much as you'd think. For example, Apple had precisely nothing to do with Linux or FreeBSD support for LLVM.
Now, you could definitely make your statement about clang, but not LLVM itself. Apple deserves a lot of credit for pushing clang forward.
On the LLVM side, however, since about 2 years ago, Google has probably has as much impact on LLVM as Apple, and you hear nothing about this, because they don't hold external developer conferences talking about it.
(You can count the number of Google presos at recent developer meetings if you want a good indication of how involved they are).
Now, of course, in reality, the credit should go to the people doing the work, regardless of where they work, but HN and other places always like to set up these things up as if they are really corporate projects.
Do you know that Chris Lattner has worked for Apple since 2005?
Chris Lattner being the "primary author of the LLVM project".
I've known Chris Lattner a very very long time (since before he worked at Apple), and have counseled the LLVM project on various issues since then. I was also involved in mediating the proposals to merge LLVM and GCC that came up, and I watched Chris sell Apple folks on LLVM and get hired.
Chris is not a primary author any more, he is a director at Apple. Most of LLVM was not written at Apple, it was written at UIUC (LLVM was started in 2000). While large parts have been rewritten since then, it would be absolutely positively incorrect to say it was Apple's project. I don't even think Apple was the first company to hire people to work on it!
Note that Chris doesn't really code much anymore (and hasn't for at least 2 years), given that he has too many people to manage.
So, now, if you'd like to point out what statements you think i made are incorrect and your supporting data, i'd love to hear it.
(I also think people use LLVM and clang interchangeably, regardless of technical accuracy. Clearly, the evolution of clang played a big part in FreeBSD switching.)
This is a fair point. However, I actually think GCC's negativity and steadfast refusal to adapt and evolve contributed more to its rise than anything else.
Apple may have brought users. But the contributors are mostly ex-gcc folks, or folks from research communities/other compiler people. They are the people that were/would be working on GCC if LLVM didn't exist.
The reason LLVM got the majority of these contributors is not because Apple made it the default compiler, or even because Apple supported it.
It's because GCC was unwilling to change and adapt in the ways that its contributors (current and future) wanted. For example, becoming a modular, pluggable compiler. RMS resisted plugins for many many years. He resisted writing out the IR. He resisted requiring newer versions of C, or C++, or ... (While GCC is led by a steering committee, RMS can override them, and the recourse is to go to the FSF board or something. I can't remember all the details of the EGCS reunification agreement). The steering committee of GCC, while all wonderful people, over time became less of GCC contributors, but refused to turn over their steering committee roles to any younger and newer contributors. This left GCC with a steering committee that, while well intentioned, and again good people, was not in any way related to the current major contributors. Part of this was just politics. GCC simply had a lot of politics (because of the FSF, because of EGCS, etc) that LLVM did not.
In any case, contributors and researchers left GCC because of this unwillingness to change. This is what caused a community to coalesce around LLVM, not Apple. People in this community advocated to their companies to adopt LLVM, and some were successful. This is why Apple uses it. This is why ARM uses it. It is because the community and it's members were successful in convincing them to do so (certainly, there is more, in that the companies saw long term strategic benefit, etc)
PS: Read all the threads here, and check a few dozens of similar Phoronix articles for-ad-clicks on the same topic on HN.
KHTML was also pretty sweet already, before WebKit was born, but it lacked the polish ... e.g. web pages weren't rendering properly because KHTML was adhering to standards, whereas Mozilla was adding IExplorer features to make web pages look nice (remember, this was back when "works best in IExplorer" was still the norm). Fortunately for all of us, Mozilla decided against implementing ActiveX (it's a pity that people don't remember these things when speaking of PNaCl or Dart).
Unfortunately, WebKit has become in a lot of ways the new IExplorer on mobiles (at least this time it's driven by standards and it's open-source). I hope Mozilla can bring some balance.
Except this is talk about standards and open-source is rubbish, because each mobile device has a different version of Webkit and users only have the version that came with the device.
The increased amount of participation probably far outweighs whatever benefit is involved from the "freedom" in forcing others to publish their changes, which actually just discourages participation from the industry and only marginally improves the ecosystem in the process.
And interestingly enough, non-programming users have this same freedom whether it's BSD code or GPL code. Even more, these same non-programming users have greater freedom with BSD code, because it's more permissive.
I think what you're arguing, obliquely, is that users benefit because there's more source code around when there's GPL than when there's BSD. This is still the core debate between GPL and BSD; does being permissive and trusting people result in less or more source code?
For me, personally, I always contribute back to BSD projects, and avoid GPL projects where there are alternative. I want the freedom BSD gives me, even if I don't exercise it, and even if I never plan to exercise it. But it's why defining GPL as "free" software comes across as double-speak to me.
I think that many people share my goal of having more source code out there, with the freedom to modify it for one's own purposes, but it's definitely not universally agreed that GPL is the best way to achieve this.
How much freedom does a non-journalist gain by having freedom of the press? I can understand the value of a free, uncensored press even though I am not a journalist. I think that users can understand the value of software freedom even though they do not write code.
>Even more, these same non-programming users have greater freedom with BSD code, because it's more permissive.
Incorrect. You are referring to the "freedom" to restrict another user by distributing nonfree software. The free software community is concerned with positive liberty[1] and freedom for the end-user instead of the copyright holder.
The GPL is incompatible with several FOSS licenses including itself (GPLv2 only and GPLv3 being the best example) and such legal issues only serve to drive away potential users of those licenses.
Personally, that's why I find the Mozilla Public License 2.0 to be the only copyleft license I can trust. It's much clearer than the GPL, it doesn't have restrictions on dynamic linking, it is copyleft to itself but it allows code to be shipped under a defined secondary license. By default these are the entire *GPL family from v2, but it can be expanded to include other copyleft licenses such as MPLv1 or the CDDL if the developer so wishes, as long as the parts under the MPLv2 are available separately from the project under that license.
This stops license incompatibilities, something that the FSF needs to work on with their licensing scheme.
But from a user-centric perspective, this is not freedom but power, specifically the power to restrict downstream users' freedom. The GPL does not give you that power, while the BSD license does. That's the main philosophical difference: the GPL says you cannot add new restrictions on distribution, while the BSD says you an add any restrictions you want, as long as you don't remove the copyright notice.
Many folks, especially Americans, feel that the freedom, for example, to kick someone else off their land (or out of their living room) is pretty important, even though from the perspective of the person getting kicked off, this is a restriction of freedom.
The BSD licence is more free from the perspective of the developer, while yes, the gpl is more free from the perspective of the user.
Personally, I think it's good that we have both. "Abortions for some, miniature American flags for others."
The fact of the matter is that under at least US law, it's the programmers choice how to licence their software, and considering that a whole lot of software is not open-source at all, both the bsd licence and the gpl licence are way better for users, I think, than closed-source software.
That speaks it all, I think.
Do you have references for that statement?
I was under the impression was that most, or at least a very large portion of open-source code was written by people paid by companies to work on that open-source code. Both on the BSD and GPL side of things.
Facebook, IBM, Google, Intel, Microsoft, Oracle, SAP are only partially open source.
Most of the stuff I see 100% open source, are companies that sell SaaS or PaaS, without giving access to their internal stuff built on top of open source. When they do, it is only a small subset of their tooling/frameworks.
That's /completely different/ from who is a 100% open-source company. Hell, you could probably call my company almost 100% open-source, but we haven't contributed a hell of a lot back.
https://www.linux.com/learn/tutorials/560928-counting-contri...
According to that, volunteers (people, as you said, who are probably actually paid to write closed source software, and do this on their own time.[1]) are a significant force, but not the majority. It looks like the majority of contributions come from folks paid to work on open source (and give the changes back) by some company or another. Sometimes those companies are not primarily open-source companies. Some of those companies are not software companies at all. Intel probably has the clearest incentive here; if their hardware works well under linux, well, that is going to tend to increase hardware sales.
Now, of course, the Linux kernel may or may not be representative of other open source projects, but those are the statistics I find.
This also lines up with what I've seen personally; most people I know who contribute significantly do contribute some of their own time, but most of them get paid to do it most of the time.
[1]I'm not sure your statement is true even there. Most of the major contributors I know who put in significant personal time do get paid to work on open-source stuff when they get paid. I mean, if you have a deep understanding of a valuable and commonly-used codebase, well, when looking for employment, working on said codebase is very likely the highest value use of your time.
Fact is, most people in HN like open source, but the reality speaks otherwise when you try to make a living out of it.
I have been through it a few times, so I speak from experience.
You hint to the fact that even if one does not get paid, the knowledge built upon working in open source can be used for building up a curriculum that helps getting a new job.
Which is true. The only problem is what to earn during the learning process, if open source is the only source of income.
Again, I am not against open source, as I actually am an heavy user of it. But based on personal experience there are only a few markets where I see a possibility to earn money from it, at a sustainable level for what is expected in western civilizations.
So, you don't believe me when I say that you can get paid by a major corporation to work on open source software, to make that software do what the corporation wants, and to give [some of] those changes back to the community?
I mean, these are plum jobs. Not something just anyone can get. But, these jobs are also where the majority of open-source software comes from.
edit:
If you are saying that it's difficult to be an "ideologically pure" open-source programmer and make a living from it, we are not in disagreement.
My point is there are a lot of jobs in and around open-source, though; I've gotten paid to work with (and sometimes make small changes to) open-source software for almost half my life now. I in no way qualify for the 'plum' jobs I described where you work full-time writing said software.
But eh, really, the same is true for most systems programming. Most programming work is CRUD apps. Only a few really good people get to work on systems programming, even in the proprietary software world.
The open-source model means that those of us who keep shit running (or those who write CRUD apps) can modify small portions of more complex programs when we find problems that are within our ability to solve.
Yes, that is my point.
The wast majority of developers work at internal code, code that never will get redistributed outside the company walls.
According to my dictionary this means closed source, which only reinforces my statement.
GPL allows this, as do every type of open/free software license. Either this mean that your word choice of "closed source" lacks meaning, or we are not talking about the same thing.
In some restaurants, you can't see how your food is prepared at all, and you judge based on your knowledge and experience of prior meals.
Some restaurants will openly show you the preparation of the food (to display that it's freshly made, reassure that there's no microwaving going on, etc).
And in most cases you can look up recipes online to try your own hand at recreating a similar meal - although often without the same tools, experience, ingredients and precise recipe, it might be tricky.
Ultimately I think it'd be wonderful for all recipes and instructional information to be available for anyone to view and try themselves if they so desired - it'd also help people understand what goes into the food that they eat (and pay for).
As for being malicious, I don't see how GPL adds anything to any other open source license.
First of all, "users" (as in non-developers) don't care about the code..never have, never will. Secondly, the code never goes away. It's not like someone can physically snatch up some BSD code and lock it away for no one else to use.
But what I find most disturbing about this line of reasoning is that it doesn't take into account the developers decision on how she or he wants to license his or her code. If you want to GPL it, fine, if you want to give it a liberal license fine too.
But since installing whichever shell one prefers is so easy, I don't see any real problems there.
http://lists.freebsd.org/pipermail/freebsd-current/2013-Sept...
The mouse-over popup spam was too much to fight with.
Back on topic: I really want to try out a non-linux kernel OS at some point, but I have nvida hardware...
There's a new things that aren't quite like Linux, for instance, the 'watch' command does something entirely different.
And I support your opinion on a "core system" being a feature - it makes things consistent, which is a good thing. For example, I tried to setup a wifi network on Arch and I needed at least three different commands for this, each with it's own options syntax. In FreeBSD there is 'ifconfig' command which does everything related to networking and that's all.
Intel is working on OpenMP support for LLVM/Clang. Runtime part http://www.openmprtl.org/ is BSD. Compiler part http://clang-omp.github.io/ is the same license as LLVM/Clang.
OpenMP is a large feature, so it will take quite some time to be integrated.
I guess if it's a big deal you can always compile gcc. Honestly I'd rather have it compiled for me but that's probably no surprise.
To me it seems that they are ignoring an important practical concern (usage of LLVM/Clang may be unlawful in the US and Europe without going out and obtaining patent licenses) in order to address a purely philosophical issue with no practical impact.
It's sort of amusing how the tables have turned over the last twenty years. Twenty years ago it was the FSF/GNU crowd who was making impractical decisions for philosophical/political reasons. ... and as time has gone on the practical importance of strongly free software has become greater and greater.
Nothing in the base system uses OpenMP. I find your assumption extremely bizarre (and scary). The kernel and the base system is the kind of software OpenMP would not be of any use. In fact, the base system is not even written in C++, but C; the only C++ components are groff and llvm (go figure).
$ lsr /usr/src/ | egrep '\.(c|cpp|h|hpp)$' | xargs egrep '^[[:space:]]*#[[:space:]]*pragma[[:space:]]+omp' | grep -v gcc | wc -l
0
By default, ports use the system compiler unless it is specifically overridden in the port's Makefile (e.g. USE_GCC=any).
http://permalink.gmane.org/gmane.comp.compilers.clang.devel/...
Of all the good reasons behind switching to Clang (or behind having a two-compiler ecosystem in general), "license purity" is IMHO the dumbest.
GCC is no longer a GPLv2 toolchain.
Right, which has been a sign that with GPLv3, GCC was on the way out for sure: if its not being kept current, it's got a limited lifespan.
> I was being specific, not making a point about GPLv3 (arguments against which I also view as dumb, FWIW).
The GPLv3 itself was shaped very much by the FSFs analysis of what it thought business users would require (filtered through the FSF's ideology -- see the limits on the applicability of the antitivoization for a key example.)
That FreeBSD would be shaped by its view of what business users want, without constraint by the FSF's ideology, should not be surprising, nor should it be surprising that that conflicts in irreconcilable ways from the FSF's view made concrete in the GPLv3.
Open-source, unix-like OS's for users whose visions align more with the FSF's views are readily available. (And nothing stops a sufficiently-motivated party from making a GPLv3, FreeBSD-derived, GCC-using OS if they really want it.)
Well, that's a viewpoint that welcomes open and reasonable discussion.
Believe me, recent GCC (4.7, 4.8) is worlds better than 4.2. We pine for something better.
Like I said, this argument is dumb. The fact that Very Important People With Decision Power are making dumb decisions doesn't make it less dumb. FreeBSD isn't really doing this to support their business customers (again, things like Android are existence proofs to the contrary), they're doing it to stick it to the FSF (c.f. some of the comments in this very thread. That's dumb.
(Which is not to argue that clang is a bad choice -- it isn't!)
This is precisly why FreeBSD chose this route. It was a deliberate communicated decision years ago from the FreeBSD Foundation. I wonder if you have ever heard this quote:
> I believe it is an established maxim in morals that he who makes an assertion without knowing whether it is true or false, is guilty of falsehood; and the accidental truth of the assertion, does not justify or excuse him.
--Abraham Lincoln
However, note that it doesn't _bundle_ it. And Google has gone to some lengths to produce their own non-[L]GPL libc (Bionic). As far as I know, the Android userland is pretty much a no-GPL zone these days.
We can discuss if one should be allowed to modify ones own property, but lets at least be clear if that is the discussion we have.
Finally a compiler comes along that shares the same license philosophy and can be imported wholesale WITHOUT having to worry about licensing issues due to changes that may need o be made.
If clang/llvm hadn't come along FreeBSD would have upgraded to a later version of GCC.
Patents. A company need to know if they have patents, or patent agreement covering the GCC compiler.
Binary only modifications to GCC need to have corresponding source code.
If you include a GCC compiler in a router/hardware device, users need to be able to run their own modified compiler.
Thats about it. Cant really figure out any more use cases where GCC and Clang would differ.
Plus, it's mostly used for proprietary mobile device offerings by big corporations.
Not many open source projects benefit by Android's existance.
However, if Mozilla, clang or WebKit had not been open-source, their impact would have been very different (and much less).
Perhaps clang will carry over to OpenBSD so the project can ditch their custom version of GCC. PCC, with its few moving parts, does seem to embody the OpenBSD philosophy more than LLVM, though.
It was recently removed in fact. There's been talk about adopting LLVM, but it doesn't support a bunch of architectures openbsd does support.
I wonder what this will do to the ports tree though!
In general, clang compiles somewhat faster than gcc (though the gap has been narrowing) and gcc produces better code than clang (though the gap has been narrowing). Gcc in general supports more architectures. Clang supports some specialized uses (e.g. embedding in an IDE) that gcc (being more of a traditional compiler) doesn't do well. The oft-repeated "error message" argument is fairly specious. Both are changing very quickly, but the trend seems more towards convergence (in capability) rather than divergence.
Clang's more modern source-base is arguably an advantage to those wishing to extend it, but that represents a vanishingly small fraction of users—and is not always the advantage that's typically suggested: I've hacked on both, and while gcc's internals can be "elderly", clang's "modern" structure is often far from simple to understand.
So, good? Absolutely. "Better"? Er, well. It's a great thing to have two excellent compilers available...
its a great OS, with a great background that should advance forward as another good open source option to linux and also against the closed source OS´s all around..
after all the heroic efforts from the FreeBSD community, to make the project going on even without the same support and attention that linux got, i wander if its not the time right now that this wonderfull OS start to get more traction and love from the hacker community?