-
Do you need to have a paid membership to actually read the paper from the ACM library?
Here’s a link to the 2Q article directly for those that would like to take a look at it.
-
-
I’m working on building some prototype batch APIs in my real job.
On the side I’m trying to focus on getting my raycasting working correctly in my rogue-like.
IMO gdb and gcc are pushing themselves out by not being competitive.
It’s one thing to argue against non-free and closed source software. But in this case lldb and clang are more free. On top of that, they’re better in many ways.
Instead of arguing against supporting alternatives, rms should focus on how to make gdb and gcc better.
LLDB and Clang are free softwares, but whether they are “more free” is precisely the contentious point. Stating the contentious point as given is a bad manner.
minor nitpick: LLDB and Clang are not free software, they are open source software. The difference between free and open source software is the contentious point you are talking about.
The funky BSD-alike license Clang/LLVM and related tools are under is most certainly free, but not copyleft. (“Open source” as used negatively by the FSF refers to software which allows users to read the source code but not to modify or redistribute it, and thus is not free software.) The contention goes the other way: some non-copyleft adherents insist that copyleft licenses like the GPL (under which GCC is licensed) aren’t free or aren’t sufficiently free.
The whole “free” thing breaks down because you need to look at it based on the needs of who is trying to use the library/code/application.
RMS is referring to the freedom of the User. They don’t need to worry about someone taking the application they really like and making it better and throwing a paid for license on it. Derivative works need to comply with the GPL as well, ensuring that the end user is always protected.
Developers/Entrepreneurs don’t like this because they want to take a library and use it to do whatever they want, which isn’t always in the best interest of their users. If their project gets abandoned or the business disappears, a skilled user is not free to take the product or library and fix it to meet their needs.
BSD licensed software also (hopefully) forms a “minimum level of quality” in the greater software ecosystem, as if there is a well done version that is BSD licensed and runs on the platform, why not use it? Common example: openssh
“A rising tide lifts all boats”, or something like that.
They may be free but they are not free software. That is the nomenclature. As far as I remember (from reading slashdot and lwn 10 years ago) the term Open Source Software was not coined by the FSF but was a move by the OSI (Eric Raymond and Linus Tovalds come to mind as proponents of the term). In an effort to distance themselves from Stallman and argue about the technical merits of open source for software development. As opposed to Stallman’s moral argument.
nomenclature aside, I’m aware of the BSDs argument.
What I think this whole GCC vs LLVM issue reveals is how terrible competition is. It destroys communities and pits groups against each other. Competition wastes resources and is one of the most inefficient ways to improve something. And most of all, there is a loser.
I truly hope that we can go beyond competition, as it is a true blight on humanity.
Friendly competition is good, look what speed wars between Chromium and Firefox did to the web. Competition doesn’t allow you to stay in your lovely ivory tower where everything is fine and dandy: you actually have to start listening your users and learn from your rivals. Although rivalry is best when it is friendly, as that will bring benefits from one project to other faster and pushes both projects forward faster than neither could do alone.
Other option is to ignore benefits that competing project gives to their users and become obsolete. Sadly this seems to be the route various GNU-tools have picked to themselves.
Friendly competition is an oxymoron. For every benefit you can claim competition has, I can show you 10 deficits it creates.
The speed war is a perfect example. Why didn’t google contribute the V8 technology to mozilla instead of writing their own browser? How many resources were wasted reinventing and rewriting the same sort of thing?
Lets look at another war, the browser war in the 90s. Competition made a MESS out of the web. Each browser vendor creates their own technology. Standards have made the situation slightly better, but not by much. There are still portability issues writing a Javascript app.
For every benefit competition has, cooperation has the same but more efficient. Cooperation also has the benefit of building community instead of destroying it.
When I am asked what level of competition is good, my answer is always “zero, none”.
Unfortunately most of us are trained to compete at a very young age and really don’t have as much opportunity to cooperate. So those skills are not as developed.
Let me tackle you main point, which is that competition drives motivation. That without it there is no motivation to improve. My response to this is that competition takes motivation that is internal and externalizes it. It weakens peoples intrinsic motivational muscles where they don’t have any unless there is an external motivation such as competition.
Cooperation would strengthen intrinsic motivational muscles where people work towards a goal for their own reasons, instead of a threat to existence that competition brings.
Why didn’t google contribute the V8 technology to mozilla instead of writing their own browser? How many resources were wasted reinventing and rewriting the same sort of thing?
You seem to be very focused on what other people choose to do with the code that they write. RMS makes the same mistake a lot.
No man is an island.
It’s more complicated than simple cooperation vs. competition.
Intergroup competition with infragroup cooperation can produce higher levels of intrinsic motivation (cf. http://psych.wisc.edu/cmsdocuments/TauerHarackiewicz04.pdf), and is arguably the evolutionary milieu of the human species.
got 404 for that link.
works for me, but i’ll rehost it for you: https://mega.co.nz/#!acxnXQhQ!C1Jj3wgdGIAZNEfOI0ZTobnd9dI9wkdGGjbladwP_DA
There isn’t anything about copying on this doc, so I assume sharing it verbatim is ok.
Thanks for the link.
The first problem with that study that sticks out to me is that the activity they used, free throwing, was chosen because there is no interference between people.
Wouldn’t that nullify or even redefine what cooperation is? The benefits that i see with cooperation, like sharing resources, talents, helping each other out, are not tested here and even deliberately prevented.
How can this study test if cooperation benefits or not when they explicitly removed what most would see as benefits of cooperation.
Only thing they tested here, imo, is if cheering for your fello man improves their performance.
What I have gathered from people working on the SpiderMonkey that time: they didn’t think it was an problem. Or to be more precise: they didn’t think making such level speed increase would be possible. Most likely it would not have been with architecture at that time! The fork was actually so good that V8 cranksaft was pretty much directly copy-pasted into SpiderMonkey: some classes has been renamed and the static analysis improvements in SM has made code divert, but the common ancestor is clearly present.
In case of FF/Chrome (or gcc/clang), the problem is that the original project that has been “forked” or “copied” because the parent project has decided to ignore their community. People wanting to see their own vision are stomped down by existing project leaders and have left with no other option than to create competing project.
Personal anecdote:
I am young and I haven’t seen the age of proprietary compilers, but to me gcc feels like proprietary project because it listens my needs even less than some company I pay money for! I could try to add features I want to have in my compiler into gcc, but those wouldn’t go through because project leadership. So I cannot use gcc based tools to do static analysis to my C or C++ project in my editor or I cannot get AST/IR out of the gcc to build my own tools. And I wouldn’t get such changes to gcc because of RMS.
To the old beards in the gcc mailing list gcc probably is savior that saved them from the shackles of the proprietary compilers. To me clang is savior that has saved me from endless headache of hatemail from people who want stab me because I forked their precious gnu compiler toolchain. Alas, I wouldn’t have lived with those awful error messages and lack of tools for much longer.
If you are using XCode then you are using a proprietary compiler.
If you are using clang directly from source then what advantage does it have over gcc for you? Are clang people more likely to take your changes upstream?
Also, you clearly haven’t used the latest gcc releases, which have better error messages in my opinion than clang.
The world is not divided into only gcc and XCode. Many of the BSDs were stuck using the last gpl2 version (I think GCC 4.2.1) of the compiler toolchain, and clang has been a huge improvement there. example
If gpl3 had been different, I wonder how things would be different today.
How many years before that were they bad?
Why did they finally improve? Was it only after clang became viable?
Cooperation like that sounds great, but the reality is that in many cases it’s easier to start over than to contribute to a large existing project.
Imagine if the LLVM/Clang guys hopped onto the GCC mailing list and said, “We’re going to throw away a lot of your work and create a more modular architecture.” It would have never happened. The GCC devs would have shut it down immediately. They’d never get a single patch submitted.
The same thing with V8 and Firefox.
Honestly, I don’t care about GCC or Clang, I just want to compile and debug my code. Whichever tool allows me to do that the best is the tool I’ll use. The competition here is being created by GCC. Clang is off doing their own thing, and GCC is in the corner whining about it. As far as I’m concerned, the GCC guys can do whatever they want. Ignore Clang and become irrelevant for all I care.
Except that GCC has huge efforts to become modular and firefox rewrote thei js engine many times. The latest is in a new programming language called rust.
Yeah, after their core developers realized they were losing users because other projects were doing those things.
My point is, it was less effort to create Clang than it would have been to deal with the politics of overhauling GCC. I mean, you can create a compiler that does what you want, or you can argue for years with RMS about whether GCC should be modified in a certain way.
“My point is, it was less effort to create Clang than it would have been to deal with the politics of overhauling GCC.”
There was a part of GCC that Apple could not overhaul, which is the GPL. In terms of just technical issues, clang is several million lines of code. I highly doubt it would have taken more effort in GCC politics than writing millions of lines of code.
It’s a lot more than just the GPL. As far as I know, RMS has been arguing against making the syntax tree and inner data structures of GCC available for plugins since before Clang existed. To think Apple could have waltzed in and said, “Here are the patches we need in GCC that make the syntax tree available for our proprietary IDE” and then the GCC guys would have just said, “Okay, thanks!” and pushed the changes along is ridiculous. It never would have happened. It’s not happening for Emacs, it sure as shit isn’t happening for XCode.
The origin of LLVM is that some academics wanted to make a better compiler backend infrastructure. gcc’s RTL-based backend was pretty outdated at the time and didn’t support a lot of modern optimisation techniques very well. It was pretty much a nightmare to work with too - a vast amount of very intertwined code which really needed drastic refactoring. Releases were getting slower and slower as maintainers struggled with the ugly code base.
LLVM was designed from the ground up to make a nicer compiler backend without all the historical code mess which was weighing gcc down. They did a good job of this. This all predates Apple’s involvement by many years.
In this case competition really helped because it spurred the gcc developers along to improve some of their techniques. gcc has cleaned up its act a lot, largely as a result of this competition.
In the interest of historical and technical accuracy:
LLVM backend is not less C-centric, not now, never was. When LLVM first came out, its primary technical advantage was SSA-based IR. Soon after, tree-ssa project added SSA-based IR to GCC.
In general, GCC backend is more language neutral than LLVM backend, because GCC supports or supported compilers for Fortran, Ada, and Java, and those were in production use. LLVM’s advantage in language neutrality is that it is easier to write frontends for LLVM. But that does not mean LLVM optimizes non-C languages better than GCC, and as I understand precisely the reverse is true.
Edit: the parent comment edited “less C-centric” out. Thanks!