Guest post by The LLVM developers seem to be driven to replace all parts of the GCC toolchain and libraries with home-grown alternatives under BSD-style licenses. The latest addition to the project is libc++, an implementation of the C++ standard library which is faster and uses less memory than the GCC libstdc++. The developers also intend to support standard library debugging which is ABI compatible to the release version, which should help developers cut down on lengthy recompile-and-debug cycles. The project is still in an early state but it already implements 85% of the C++0x standard library. As with the rest of the LLVM project, the development of libc++ is being supported by Apple.
Its nice to see an even more free alternative being developed. Getting tired of the religious political “cant-ever-turn-it-off” attitude of some of the most vocal GNU/FSF advocates, so it will be nice to be able choose another alternative
Large parts of GCC have been rewritten a few times, but I feel as though GCC is starting to feel its age. Not that it couldn’t be rewritten, but it’s the devs that are the problem. They get stuck in a certain way of thinking, and that limits their ability to continue to advance.
LLVM is isn’t actually what makes the Clang et al better. GIMPLE, Java byte code, .Net byte code, and LLVM all have similar intentions. They’re an intermediate representation of compiled algorithms. GIMPLE is designed to be purely an intermediate representation that will be compiled. Java byte code was originally designed to be interpreted, so that’s what it was optimized for. LLVM is a bit more like .Net byte code and AS400 byte code. It’s intended a priori to be “released” and then JIT compiled later.
But what is really making Clang a better compiler is the enthusiasm of the developers and the “freshness” of the implementation that drives the developers to create a cleverer, better solution. The GCC developers are motivated instead to create something STABLE, which involves modifying old stuff only minimally.
Eventually, Clang will mature and stablize, and then progress will slow down. Eventually, it’ll get crufty, and a new compiler framework will have to be developed. And that new framework will be benefit from newer technologies and research in the area.
This is the way technologies evolve, and it’s a good thing. So let’s benefit from Clang and LLVM now and learn everything we can from it so that the next time around, we’ll do even better.
Agreed. The real problem is that it’s taken so long for anything to try to be different than GCC, while also being able to [eventually] replace GCC.
If this stuff gets old and crufty, and needs to be done over, that’s fine. However, we need to keep it being done.
What’s been happening until recently were small projects that went nowhere. So, realistically, you could either use the GCC’s libraries, or you could use uClibC/Cpp, neither of which are really ideal (throughput often suffers w/ uClibs, but the same old apps are so damn snappy, too).
GCC won’t die–there is value in an old, well-tested, supports-tons-of-OSes-and-hardware set of software to build with. But that’s been the only thing out there for general use, made to be efficient in its performance, that doesn’t take immense efforts to make use of across-the-board.
Edited 2010-05-16 21:53 UTC
We might start talking about Clang being a better compiler once it can compile all the C++ that gcc can.
I believe that they should concentrate their efforts on proper C99/Objective-C and debugging support
LLVM is started as science project for purpose of advanment in compiler technology. Clang on the other hand is started by Apple from pure hate for GPL, FSF, and GNU. They are scared of Free, GPL’d operating systems like GNU/linux, and they found out that their anti-GPL propaganda would not work if they use GCC. So they decided to get rid of that before they go openly hostile to FSF and GPL-licensed projects. Expect them to start suing likes of Canonical, Red Hat and FSF in year and two.
Or maybe they want a set of compiler tools that they can modify as they see fit without the need to release their changes. GCC is GPL while clang uses a BSD license.
> modify as they see fit without the need to release their changes.
You know, so they have freedom to modify the code and STOP you from doing the same. With GPL this doesn’t happen, you still have freedom to modify the code of the derived program.
Apple can’t stop anybody from grabbing the sources from llvm.org and modifying them.
BSD license allows stopping releasing the sources.
BSD licenses allow proprietary forks, but they don’t give one company the power to crack down all forks from the FOSS upstream project. LLVM will be free whatever Apple does.
As we all probably know by now, reading osnews by example, Apple’s way is CONTROL, CONTROL, CONTROL, even if they make clearly abusive decisions. We can’t deceive ourselves, Apple think a lot and arrived to the conclusion that this LLVM business is their best way to their known interests
As we all probably know by now, reading osnews by example, Apple’s way is CONTROL, CONTROL, CONTROL, even if they make clearly abusive decisions. We can’t deceive ourselves, Apple think a lot and arrived to the conclusion that this LLVM business is their best way to their known interests
I don’t see the problem. So the BSDL allows proprietary forks. So Apple might put in some secret sauce in their branch. The original project will stay free and what ever Apple does with their copy, they can’t restrict what others do with the vanilla BSD code.
What it might mean is that the vanilla project doesn’t stay “Apple-compatible”, so that you might be forced to use the Apple-variant if you want to use it for Mac OS X development.
Then again, if one is so concerned about freedom in development, one shouldn’t develop on a closed OS like Mac OS X.
Yes. One of the keys when the GPL license was made was to avoid that your work as a programmed can be used by closed, proprietary system, to serve only their own company benefits.
Yeah ok but that’s not the point. I think lots of ppl misunderstand what the GPL is about. It’s about guaranteeing the 4 fundamental freedoms: http://www.gnu.org/philosophy/free-sw.html
You’re thinking of software where you already have access to the code, and under a permissible license. That’s not a problem, obviously. GPL wasn’t created because the world needed yet another permissible license. GPL was created to solve a particular problem:
Say you come across a random piece of software (compiled, no source code). The GPL is saying that, ideally, you should still have the 4 freedoms. If that software is GPL-licensed, you most likely do [or can get them with a bit of effort].
If it is BSD-licensed, there’s no saying, because BSD doesn’t enforce any of the freedoms. You may have some or none of them. Realistically, probably you most likely don’t.
PS: I don’t say this to bash BSD. The above is not a “flaw” in BSD. The GPL and BSD start from very different mindsets and they are each adequate for different goals. I don’t see any sense in comparing which is “more free” when the very definition of “freedom” is different for each mindset.
Edited 2010-05-18 13:40 UTC
Fundamental to who? What you call freedoms I call demands by Stallman. I could just as easily create 5 fundamental freedoms built around the BSD license. And since 5 is greater than 4 my license would have a greater amount of freedom. I would call it the Mega Fundamental Eagle Freedom License.
You know Stallman could have described his license in technical terms instead of wrapping it in his freedom fries talk. But then I supposed he wouldn’t gain so many dedicated followers if he didn’t portray the whole thing as a liberation movement.
Why so many people follow someone who pushes his own carefully crafted definition of freedom is beyond me. It actually creeps me out that so many people go along with it. Maybe I should quit programming and start my own cult. I’ll build my own freedoms around my personal desires and my cult members can find “freedom” by serving them. They can also free themselves of society’s demands and pressures by living on my compound. Freedom for all my members, as specified by the sacred 11.54 fundamental freedoms that I created for them while sitting on the toilet.
Well let’s compare the definitions, shall we.
The GPL message is: “you can do anything EXCEPT limit other people’s ability to also do anything”. BSD’s message is: “you can do anything, we don’t care, we hope everything turns out for the best”.
In today’s day and age lots of people apparently think that the GPL approach is more practical. What use is absolute freedom if anybody can come and take it away? It becomes just an abstract with no practical value. Freedom needs rules to define it and it needs someone to enforce those rules. Otherwise it’s just a “free for all” deathmatch. The next time you say “you’re free to do [WHATEVER]”, think of what grants you that freedom: it’s the laws, and the police and so on who enforce them.
The GPL and its freedoms are not something someone “created[..] while sitting on the toilet”. They are carefully thought out, they have a practical use and have been proven (in courts and otherwise) to serve a real need and even to revolutionize the way we look at software. I’d say Stallman’s idea was a good one.
And, how do you know it’s licensed under the GPL, if all you have is a binary file?
Just because the source is licensed under the GPL and has a bunch of notifications of such strewn around the sources, doesn’t mean an unscrupulous company can’t release a binary without any indication of it being GPL’d. Actually, quite a few companies do this every day. Some get caught, some don’t.
Again, how do you know it’s BSD licensed if all you have is a binary file?
And if all you want to do is run the binary, does it really matter how it is licensed?
You’re nitpicking but ok.
Let me ask you when’s the last time you got a binary that had absolutely no indication of where it came from. No license, no author, no EULA etc. Usually most software has something like that.
It does if you care to (or need to) comply with the law. If a binary doesn’t come with an explicit license to do something, you can’t. Some countries have copyright extemptions into their laws which grant some personal use freedom in spite the restrictions, but then some don’t.
And that’s just for home users. Many organizations don’t have that luxury. They need to be able to account the legality of all software they use.
On a side note, if you’re willing to run a binary where you have no source, no idea who made it or where it really comes from… I pity your computer.
First of all, I don’t see how you can say for sure that “quite a few companies do this” and then admit that “some don’t [get caught]”. How do you know they do, if they don’t get caught?
And of those that do get caught, they get punished. All GPL violations so far have settled or been punished. And that’s what I meant with “a bit of effort”.
Edited 2010-05-19 09:07 UTC
Well, does it really matter? LLVM is under an even better license than GPL with even more freedom, so why not just enjoy it like the rest of us?
Even better license… for Apple and propietary companies. Worse license for you, you lose the power of modifying the program. You have to swallow the program without any modifying chance.
What does that mean?
LLVM is under a bsd style license. This means that you can basically fork the project and license the new version under LGPL/GPL if you feel like it.
That’s only if you have the source. The BSD license allows them to stop releasing the source, stopping you, without any chance of modifying the program, giving them the total control of it.
Yes, but as I understand it the source up to the point when they stopped releasing it would still be available, assuming someone, somewhere had made a backup of it. Thus, the moment a company “stops releasing the source” (i.e. they stop releasing their improvements to the source), a fork can be started utilizing everything released up to that point.
It’s also worth noting that for many large GPL projects, the copyrights are all signed over to a single company, which means that that company could change their license away from the GPL any time they want–which at the end of the day means that that company has almost the same freedom as with a BSD-licensed project.
Edited 2010-05-16 21:49 UTC
Care to elaborate? I’m thinking of what I use, the largest GPL projects: the linux kernel, KDE, gcc, and they are not signed over to a single company, of course.
It varies from project to project. The GNU requires copywriter assignment for all projects, including GCC. Sun microsystem requires copyright assigment for all OpenOffice contributions.
Reading the terms: “The Sun Contributor Agreement is very liberal, as it requires sharing the copyright instead of fully transferring it and also guarantees that published contributions will remain under an open source license forever.” from http://www.openoffice.org/FAQs/faq-licensing.html#sca1
Are you mad? Who is going to stop releasing the source? The University of Illinois? Are all the mirrors going to disappear as well? All the local copies that exist?
Of course I’m talking about next versions, derived works and so on. This version is not going to last forever, as you know.
No I don’t loose that power. Besides, I don’t mind companies also being able to use the code. I see it as an advantage.
With GPL the companies can use the code, but they can’t hide it to you, so you can modify your programs and the companies haven’t that control over you.
The history is plenty of programs that make use of BSD code that you have programmed, but in their versions they stop you from getting to that code, you depend on them, that’s one of the things that you lose.
Well, if companies will fork the code, then fine as long as the original stays under the same license. The companies have no control over me yet. I can always decide NOT to use their product if they do. That is why I think BSD have more freedom; the companies are not obligated to give me anything for free, and I can choose not to use their product as a result.
I don’t hate companies, and I don’t hate anything proprietary. I just personally prefer (what I consider) free software, and therefore use it as much as I can. If I can use the code, why should not companies be allowed to do the same. Thats true freedom for me. Not artificial restrictions based on the assumption that all companies are evil and wants to destroy mankind. Then its politics (and a shitty one as well, based on hate), and has nothing to do with excellent software. So take your hate elsewhere and stop feeding me this crap. If you want GPL then stick with GNU and GCC. Its still excellent software, if you prefer software that is bundled with all that political idealism. OR you could also just use LLVM under the BSD license and discover that the software is just as excellent under BSD as it would be under GPL, AND you have access to the code. Its not really that hard.
The issue would be if whoever is in charge of LLVM suddenly decided to change license for future versions into something proprietary, but then again, that is the same issue if the code was GPL instead of BSD.
EDIT: fixed the quotes.
Edited 2010-05-17 22:05 UTC
That is what monopolists do not want. They don’t want you to choose. So they have plans, and use BSD to get the code that free software programmers do… in their monopolist, close-source, try-to-force-to-use programs. That’s why Apple, Microsoft,… use code with BSD license
Oh that is their plans? What about mutual interest?
For a company like Apple who makes their money selling a packaged product it doesn’t matter if they fund components like Webkit that aren’t a threat to their bottom line.
It isn’t as if they could sell Safari given the amount of browser competition that exists. They just want their own browser and don’t care if the core of that browser is open source and used in other projects.
Furthermore to sell software that is based on a BSD fork the company needs to add significant value or else people will just use the original code.
With GPL the companies can use the code, but they can’t hide it to you, so you can modify your programs and the companies haven’t that control over you.
What about just rejecting to use closed source software? Problem solved. No company can hide anything from you, if you opt to stay with purely open code.
You mean you don’t have source access to functionality that they have added to their own fork, which means you actually haven’t lost anything from your own base.
But I would like to hear some of this history involving BSD code that you speak of.
OpenSSH is commonly used in proprietary systems and yet I don’t see any company pushing BetterSSH. Where are the Apache forks?
But even if a company produced SeminoleWebServer that company would still have to compete with Apache and all the other web servers.
If Apple “hates” the GPL, why does Apple use and distribute so much GPLed software? GCC, bash, etc. are all part of Mac OS X.
Even stranger: If Apple “hates” the GPL and is “scared” of Linux, why is Apple maintaining CUPS under GPL for various operating systems, incl. Linux?
If Apple is “scared” of Linux and Free operating systems, why does Apple develop FOSS compilers like LLVM and Clang that either work directly on Linux or are at least easily adaptable to Linux? Why not just take LLVM and produce a closed-source fork (which would be perfectly legal)?
And which “anti-GPL propaganda” are you referring to? “Get the facts” was a campaign by Microsoft, not Apple. Considering that Apple is using, distributing, and even contributing to GPLed software, how can Apple have “anti-GPL propaganda”?
Apple’s Darwin/Unix team consists of many people who come from the BSD world. No one from the BSD world is overly fond of the GPL, but only very few hate the GPL.
All BSDs have the policy to not accept GPL code into their core code.
At least FreeBSD has the policy to not include GPLv3 code in the base distribution, which is why the FreeBSD project only ships older GNU software (incl. GCC) as part of the base distribution.
Apple’s work on Clang/LLVM helps Free OSes more than it hurts. The BSDs are all eager to get a GCC alternative and even within the Linux community (which I am part of) likes to see an open alternative to GCC which results in the option to use either compiler depending on the use case.
Correlation does not imply causation.
That’s not an answer to my questions.
But it is a comment on the opening point of your previous post.
Apple hates GPLv3 not GPLv2
.
Apple has the same GPLv3 policy FreeBSD has.
FreeBSD is moving to libc++ ASAP.
This is the first I’ve heard of this, and actually I don’t understand it. As I recall the BSDs were the only ones able to integrate things from OpenSolaris (ZFS, DTrace) because of the compatibility between the GPLv3 and BSD licenses. It was only Linux with it’s “GPLv2-only” license that had problems integrating GPLv3 software. So why are Apple and FreeBSD now trying to avoid stuff licensed with GPLv3?
ZFS and DTrace are under a special license cooked up by Sun, not the GPLv3.
Politics.
This is the first I’ve heard of this, and actually I don’t understand it. As I recall the BSDs were the only ones able to integrate things from OpenSolaris (ZFS, DTrace) because of the compatibility between the GPLv3 and BSD licenses. [/q]
Not even close. Sun uses the CDDL, not the GPL, which is why Sun software has been ported to FreeBSD and not Linux. The CDDL is not compatible with any version of the GPL. But it is compatible with the BSD license.
Apple has stopped at GCC 4.2 and libstdc++ 4.2 due to the GPLv3 code moving forward by the folks at GCC.
Howard Hinnant who is developing libc++ and Chris Lattner who lead and created LLVM make it very clear that Apple will not have GPLv3 code in their developer tools.
I for one am glad these solutions are coming. DragonFly gives one GCC-4.5 as well.
The flexibility in licensing tools under LLVM should not be debated. If I want to have my GPLv3 tools and my BSD tools I can. I’ll just have to be smart about my goals and which road(s) to take, depending on the project.
Or, maybe, like many others, they weren’t happy with the GCC toolchain, and they figured they could put money behind making something they like better. Apple is good at just taking FOSS when it suits them.
However, they aren’t bad at helping community efforts, either, when it suits their needs. Just don’t mistake what Apple is doing for altruism, nor what the unpaid developers are doing as being work for Apple.
Something like a an entire build chain, from debuggers to talk to your IDEs all the way down to native code, I think Apple knows as well as anyone else that fully closed source is just not something that will help, today. GCC’s general age and bloat, and desire to keep things that way, has helped to create a significant group of previously unorganized people who want something different. A little real Apple money, a little real leadership by engineering types, and boom.
Seriously, the black helicopter licensing theories are tiring and pointless. Apple’s wants and needs coincided with the wants and needs of others, and they’ve helped foster their potential to create this wonderful set of software. Broken clocks are right twice a day, and the same can be said for greedy egomaniac control freaks.
If you’re all worried about it, keep your PC up to date with the sources, and make your own fork, from the latest BSD-alike licensed code, if they close it.
Edited 2010-05-16 22:00 UTC
LOL! I was getting ready to post an anti-Apple note just for fun, to rile people up but I should have known that I wouldn’t have to.
Even when Apple does some little thing “right” they are demonized.
Ah well. Conflict is the spice of life!
I find it really sad and annoying that comments on posts like this focus more on the license than the technology. No one is trying to “kill” anything here, GCC and GNU projects will continue to exist and improve and you can choose to use them if you wish.
Instead of trying to “kill” things, realize that members of the LLVM community are focused on building a better widget. Much of what drives these people is that innovation in the compilers and low level tools space (at least for the C family) had basically stopped, and done so at a pretty pathetic point.
If you’re a programmer and have to use these tools, you should rejoice: not just for the great things that the LLVM project is providing if you use it, like faster and more usable ( http://blog.llvm.org/2010/04/amazing-feats-of-clang-error-recovery…. ) compilers, but also by raising the bar so that other vendors will start doing the same. There are many ways that the LLVM project has directly lead to improvements in GCC, whether it be the design of their GIMPLE IR or their new focus on improving modularity ( http://gcc.gnu.org/wiki/ModularGCC ) and diagnostics ( http://gcc.gnu.org/wiki/Better_Diagnostics ).
But you’re right, lets debate how license A is better than license B, or how company X wants to kill babies – and that donating enormous engineering resources to open source projects is somehow the way it’s going to happen. Remember that while the BSD license allows Apple to fork Clang and libc++ and not contribute back changes if they theoretically cared to, Apple started both of these projects, and nothing required them to open source and nurture the community around them in the first place.
-Chris
Edited 2010-05-16 20:54 UTC
Yes, but that’s not surprising. The developers behind libc++ have been pretty honest that the license is the main reason they created it, rather than just improving libstdc++. The other reason being that they’d like to break ABI compatibility to bring improvements, which libstdc++ is doubtful to do.
So? This is the attitude of many projects rooted in the BSD communities.
For example:
– a new “tar” by FreeBSD instead of GNU’s tar: http://people.freebsd.org/~kientzle/libarchive/
– OpenCVS by OpenBSD: http://www.opencvs.org/index.html
– NetBSD’s GnuPG clone: http://netbsd-soc.sourceforge.net/projects/bpg/
BSDs prefer BSD licenses over the GNU ones… surprise…
Get this: The GNU guys prefer GNU licenses over BSD ones!
Edited 2010-05-17 00:39 UTC
I never said that was a bad thing, just that it isn’t surprising that the news brings up talk about licensing and not just the technology. It’s one of the most important features of the new software, and therefore news.
Sure, but GNU guys don’t rewrite BSD tools just because they don’t like the license.
True, but they have rewritten other utils because they don’t like non GPL licenses.
Edited 2010-05-17 13:54 UTC
Not true. FSF does not dislike non-GPL licenses in a same way Apple and BSD camp “dislikes” (more like hates) GPL.
For example, GCC recently got support for Google Go, and front end and is under permissive license. FSF have no problem with that and they do not advocate that people should not contribute to permissively licensed projects.
Other example, look at big Linux vs OpenBSD wireless drivers dispute. Linux guys took driver from OpenBSD and removed ISC license. OpenBSD resident troll, Theo de Raddt, immediately started flaming and calling names of all Linux kernel developers, even though they did not done anything illegal. And then Software Freedom Law Center (which is legal wing of FSF) interfered and convinced Linux devs that licence their changes to driver under ISC license.
http://www.linux-watch.com/news/NS2902106404.html
So FSF does no hate permissive licenses. They think it is poor choice compared to GPL, but they love all Free Software regardless of the license and they want all Free software devs to be happy.
The problem kicks in when some corporate shills start advocating BSD license as more free (and omits the fact that it is in fact free as in free lunch for his company, not free as in freedom for downstream customers) and start talking how GPL is terrible and how all GPL’d software should be shunned and replaced with “truly free” (as in free lunch for corporations) alternative.
That is where people get upset and flames happen. That is what Clang is all about.
Sure they did. BSD licenses are GPL compatible, but that does not mean that a GPL coder is allowed to remove the original license text.
In your linked article, there is a SFLC article linked: http://www.softwarefreedom.org/resources/2007/gpl-non-gpl-collabora…
It clearly states what I wrote.
Everyone in the BSD communities thinks that the BSD license is more free than the GPL.
In this case freedom is not objective.
No. Clang is about taking an entirely different approach to compilers in general.
If the main factor was the license, Apple could’ve adopted PCC, TenDRA, or some other BSD-licensed compiler of which most predate LLVM.
That’s because most BSD licenses are GPL compatible. That means that they can be incorporated into GPL projects.
However, older BSD licenses are not GPL compatible, because they contain the so-called “advertising clause”. Software using that license is sometimes recreated under a GPL compatible license. OpenSSL and GnuTLS is a prominent case.
You do realize you’re responding to the creator of LLVM whom works daily with the creator of libc++ at Apple, correct?
I believe the correct response to this is “PWNED!”
<sticks on tinfoil hat>
Imagine this scenario: LLVM matures a bit more and is ready to be a complete replacement for GCC.
Apple takes the code, modifies it a few ways, and rebrands it the iComplier, which they begin charging hundreds of dollars for. They stop contributing back to LLVM at all.
The modifications to the iCompiler mean that the output can only run on OSX/Apple hardware, and they simultaneously modify OSX so that it will only run software compiled by the iCompiler.
<takes hat off>
Is that likely to happen? Probably not. But given the way Apple has acted over the last few years, i wouldn’t completely rule it out, either.
I suppose proponents would say that even in that scenario, we end up with a decent BSD compiler ourselves, which is true. Anyway, that’s why I have mixed feelings about LLVM, and I imagine I’m not the only one. The technology within LLVM is clearly designed better, and the code much cleaner, so I can definitely see the upside.
Very possible scenario, but how would this hurt the non-apple community? The code up until apple’s fork would still be open and up for grabs. It is nice to have Apple contributing to LLVM up till this point, but it isn’t a must.
Again, this would not affect any other OS than Apple’s. Even if a BSD licensed LLVM would not exist, there would be nothing stopping Apple from doing this. Either way, this will only affect apple’s OS….
Well the downside would of course being that development would slow down on llvm/clang if the Apple paid developers would not release their code. That said, I’ve seen no indication that this would be the case so let’s not paint the sky black just yet
It is doubtful they would do that because there is no value in the compiler – Microsoft distributes their compiler free of charge in the Windows SDK. The value for the development tools come in the form of the IDE which dictate whether a programmer performs like a Mozart or code or an old fart with Zimmer frame. At this point it is highly doubtful that Apple would charge for their development tools because at the end of the day what they want to do is have the barrier to entry as low as possible as to bring in as many programmers as they can onto the platform. More programmers targeting the platform means more products available on the platform which means it is more enticing for customers to purchase a Mac – to quote Steve Ballmer, “Developers, developers, developers, developers!”.
For Apple the technology is ultimately a means to an end rather than an ends in of itself. Just look at the *NIX world as an example of pretty much large sways of code and projects and yet there is a complete failure to turn all those projects into a single coherent operating system for the masses. That is something the Linux advocates on here can’t seem to get through their head – Microsoft and Apple don’t fear open source because they know that to deliver a product it has to be more than just a bunch of random packages thrown onto a cd with a little note saying, “best of luck – you’re going to need it!”. People want a coherent integrated operating system that takes all those components and delivers a consistent user experience – and that can only be achieved through a cathedral top down style of management rather than the current situation of a project with people each doing their ‘own thing’ and once every 6 months bringing the stuff together and slapping a label on it.
Anyway, back to LLVM, there is nothing mentioned about Mac OS X at WWDC because I assume there is nothing yet planned for Mac OS X or that what has been planned isn’t in the final stages – many times when Apple announce something it’ll be off the back of something that has been in development for over a year and it is 95% assured of finishing the project on time. In the case of 10.7 I have a strong feeling that we’re going to see a move to LLVM as the default compiler with WWDC 2011 being the venue for that big announcement with a harmonisation between PhoneOS and Mac OS X with a settling on a single compiler for both and the SDK being closer to each other.
Actually the free version is crippled, two of the most effective optimizations are not available: Profile Guided Optimization and Whole Program Optimization.
True, but in terms of ‘can it compile’ the answer is ‘yes it can’
What ever the case maybe the value sits on top of a basic compiler and I’d argue that Profile Guided Optimisation and Whole Program Optimisation aren’t part of a ‘basic compiler’ but a value added component in the same way that an IDE is value added or UML modeller is value added.
I think the Windows SDK compilers fully support PGO and LTCG. As far as I know, the sdk is just a slightly minimized version of the Windows build environment.
Nope, and if my memory serves me openmp is also not available for the free versions. PGO for instance is provided through a special .dll which is not available in the sdk/express versions. Obviously Microsoft feels that omitting this functionality in the free versions will make the commercial version more attractive.
There’d be a lot of value if it was the only way to get a program to run on OSX. Intel charges for their compiler and MS charges if you want all the features, and they don’t even have that advantage.
iPhone developers might disagree. They’ve already banned non-certified compilers on that platform, specifically to freeze out some of those developers you think they want.
But how many people go out and buy Intel’s compilers? how many people go out and buy just Microsoft’s compilers or would sooner purchase the whole kit which includes all that is required for an integrated work flow? Intel’s compilers will be of value but only to a small number of people. When I talk about ‘no value’, I am talking about the large mainstream bulk of developers and not the niche developers who need to squeeze every drop and willing to pay for hyper-optimised compilers with every tweak humanly imaginable.
I’ve heard both sides of the argument and the problem I have with the whole debacle is the fact that the only way you can load on applications is through the appstore. If Apple refused to allow applications not compiled with their compilers in the appstore but allowed people to install applications manually then I could live with that position but to simply ban non-Apple compilers because of the fear bad press rather than a real reason.
You seem to keep missing the most important part of the argument. If it was the only way to run a program on OSX, developers would be forced to either buy the compiler or give up 10% of the US market. 10% of the market makes the cost of a compiler minuscule, it’s the cost of porting the code and maintaining it on the different platform that is going to decide whether or not you do it.
Ah, I see what you mean – thank you for the correction. I guess I’ve read far too much into some articles that tried to claim that compilers are becoming commodities.
Oh come on they would have to break application compatibility to even do that.
That would be the worst possible way to lock developers into a single development kit. There’s a thousand better ways of doing it (shudders).
But it is quite entertaining to see Fossologists in a tizzy over this.
If it was the only way to run a program on OSX, developers would be forced to either buy the compiler or give up 10% of the US market.
You can also turn that around and say that developers could just drop that ten percent short term and crank out good code on other platforms. Without good and plenty third party apps, OS X market share would dry up quickly. No one wants to use an OS that doesn’t have applications available.
What OS X loses in such a scenario will be gained by other platforms.
NVIDIA is already working on their proprietary fork of LLVM which they will use for CUDA optimizations. Note that NVIDA never opensourced anything, so not only their CUDA-specific extensions would be proprietary, but every line of code they write.
That is what crepes me out with BSD license. It gives to much power to greedy companies, basically sets whole open source movement back because companies have all community developed code and then some. That is why no BSD licensed program never gained popularity as open source. BSD zealots always point at proprietary fork as “their success”.
And about “license vs technology”..? Clang is written because Apple and BSD zealots don’t like GPLv3 and they never stated what clause they do not like. Since they had no problem with GPLv2, it is probably some new clause, but nobody cant figure out which one because they are not telling. If I had to guess, I would say patent clause. If Apple contributes to GPLv3 GCC, they waive right to sue FSF over it, and they probably want to reserve that right so they can sue competition when they roll out pricey iCompiler.
Well, what is supposed to happen is that good, productive developers don’t work for greedy companies like Apple.
An ecosystem is supposed to flourish around truly free software such that those developers who want to work on say excellent compilers will find a place to do so and make their living because greed does not motivate them the way it does Steve Jobs et al.
Apparently the engineers at Apple have either drunk the Kool-Aid entirely or have really, really big mortgages to pay.
How stupid do you think developers of BSD-licensed software are?
They chose it, because they don’t mind at all who takes the code.
If they want to chose that license, you have absolutely no right to complain about it, because it’s their code.
So X.org is not popular? How about the Apache Web Server? (The Apache License is just a glorified BSD license.) OpenSSH? Mesa? zlib? libpng? libjpeg? LittleCMS? ….?
Sure they are. The “anti-TiVO-ization” clause.
I for one cheer for LLVM/CLANG. Competition has the tendency to speed up evolution and in the end, both Linux and BSD users will benefit from it!
http://lists.cs.uiuc.edu/pipermail/cfe-dev/2010-May/009065.html
Excerpt: