It's not so much that as there is the net-negative side effect of having people redo the same work over and over again at their day job or whatever. It horrifies me when I think about the number of hours of people's lives wasted on things like that.
It applies to both sides of the argument, with organizations keeping things to themselves or others avoiding codebases for the inverse reason.
> It's not so much that as there is the net-negative side effect of having people redo the same work over and over again at their day job or whatever. It horrifies me when I think about the number of hours of people's lives wasted on things like that.
Given that this issue applies to all proprietary/non-opensource software, which is the overwhelming majority of software out there, you can hardly blame GPL3 for this fact of life.
I would argue that in many ways (that vary from project to project) the duplicated efforts are a good thing overall. Now, instead of having one single group or person working on a particular topic, there are many and the knowledge, learning, experience, and expertise that comes from that isn't locked up with only a select few. That can be applied in more areas, used for more things, or carried into other endeavors. It also hedges against all that expertise being lost if the few experts of the original project abandon it for whatever reason.
I don't see all the efforts that go into *BSD, Windows, macOS, etc... as being wasted just because Linux is available, nor would I consider the effort to try something completely new in os/kernel design that starts from a clean slate a waste, even if it doesn't end up becoming wildly popular. Not everyone who has the capacity to work on a duplicate effort would be able to contribute to the original, and the original will never be able to perfectly meet the goals/needs of everyone.
LLVM exists because its original developers wanted to do research, not because of GPL and at the time there wasn't even a C compiler for it, not to mention that GCC wasn't designed at all to do what LLVM did.
The license angle with Apple did happen because of GCC's switch to GPLv3 but that came years later - and GCC still wasn't (and AFAIK still isn't) designed to be used like LLVM or (later) Clang, like using it as a backend for IDEs, analyzers, language servers, etc. The two projects aren't interchangeable with only the license being the thing that differentiates them.
gcc was specifically designed to not have many reusable parts to avoid people ripping them out. modularity only happened after LLVM and clang specifically started eating its lunch.
> LLVM and clang specifically started eating its lunch
I don't know how you can eat GCC's lunch. I feel like in this analogy GCC eats from a communal trough and is very happy to share. A company that sells licenses can lose customers, the GNU project just wants the world to benefit. GCC is still ubiquitous and has plenty of developers and mindshare, what more could they want?
Basically most of the embedded folks that used GCC forks are now on clang, and if in the old days they were breaching GPL, nowadays they are fully compilant, so not upstreaming is not even a legal issue any longer.
I don't even understand how you can point to LLVM as an example of this failing. GCC is still alive and well, and perfectly suited for the task it was always intended to fill. People that wanted a commercial C compiler always had the option to purchase one at-cost, GCC was intended as an alternative to that process, not the alternative. It may be hard to remember, but less than 50 years ago squabbles over compiler licensing was what most developers had to deal with.
Respectively, LLVM fills it's own gap nicely. It has the classical BSD-like issue where hundreds of unique and disperate forks exist with no roadmap to bring them together, but that's also technically a "feature" of each license and not a bug. If GCC developers felt their job was obsoleted by Lattner, there wouldn't be a reason to update and maintain it. The end result has been healthy competition, accountability for either team, and better optimizations for everyone using either compiler.
It applies to both sides of the argument, with organizations keeping things to themselves or others avoiding codebases for the inverse reason.