CUCK LICENSE BTFO

...

Zapcc source code:

#!/bin/shexec ccache clang $*

ITS THE KIKES

Oh, no! They "closed the source!" Nobody will ever be able to use clang again!? What was Apple thinking, investing in clang? Now they'll have to pay for Zapcc! And so will FreeBSD!!!! FreeBSD not free anymore!! BTFO!!!!!

Yeah, nah. So let's review. Non copyleft free software licenses don't transfer copyright. What that means is that if the clang people license clang under a non copyleft license (as they have), whatever work they do on clang belongs to them. If someone else takes clang and adds their own work to it, their additional work belongs to them, and they can choose to offer it under similar terms as the clang people did, or different terms. If they choose to offer their own work in combination with clang's work under a proprietary license, nothing has been taken away from clang. Every line of code the clang people wrote still belongs to the clang people. There has been no cucking.

If a project offers software under a copyleft license like GPL, that project's work is theirs, just as in the previous scenario. But if someone else adds their own work to it, that new work, in practical terms, also belongs to the original project. There has been no transfer of copyright from the new project to the old, but few of the protections of copyright remain; hence, the term "copyleft". That is cuckoldry. Linking a 100,000 line project of your own original work against a GPL'ed library (like readline!) for minor functionality means you've infected your project with license AIDS. A poz bull has stuck his leaking cock into your project.

Prep your bulls, GPLfags.

...

Do you know who is the principle sponsor of Clang? Apple. They actually want people to make use of Clang in this manner by their choice of a liberal free software license (BSD-3).

I am now a proprietary missile

The benchmarks are really good though. They aren't apparently doing anything too special but obviously their code werks and beats clang and makes it run to the forest.

gnu.org/philosophy/free-software-even-more-important.html
kill yourself

Either at least highlight the relevant section or fuck off.

Delete this thread immediately.

no u

...

Underrated post.

The chutzpah of gnumales has no bounds, nothing has been taken away from anyone, all the source code from clang is free and will forever remain free. Nothing and no one can change that, not even the copyright holder.

You know, it's called the cuck license, not the "use a magic device to erase my wife fro my memory". The thing is that people who contribute to Clang indirectly contribute to derived proprietary software.

Inane

LGPL is the license that made FOSS even a remote possibility.

And what do I loose?

Nothing, you lolbertarian. But you help proprietary derivative exists, which I am sure nobody likes here.
In the end, we're still at the

Self-respect.

Hold it right there fucko, that's proprietary code!

You seem to be forgetting based CDDL, my friend.

The irony that you all play the slavery card so fast, when it is you who selectively chooses the people that do and do not deserve what you call "rights".

You seem to miss the point: GPL restricts people from restricting other people's freedom. Kind of like how that one philosopher said that your freedom ends where another's begins, not any closer or farther. Proprietary software is like anarchism in that same metaphor: you can only wish that they play by the rules but no one can wield authority upon them if they don't.

GPL allows freedom and mandates that no one must hurt other people's freedom. It's quite simple and a charming idea both on paper and in the wild.

BSD cucks never fail to amuse.

>>>/reddit/

I'm mocking the purpoted innovation behind Zapcc bitch, not closing my eyes to the problems with the cuck license

you waste a chance to build a freer society to live in

What are you talking about? Everybody receives the same freedoms with the GPL; even Microsoft and Hitler.

Where do you think you are, redditor? Go back to your shithole

Neither GCC nor Clang can optimize bar to the same instructions as foo, so they're equally shitty as each other.

#define N 100void foo(int *x) { for (int i = 0; i < N; ++i) x[i] = x[i] * 7 + 3;}void bar(int *x) { int intermediate[N]; for (int i = 0; i < N; ++i) intermediate[i] = x[i] * 7; for (int i = 0; i < N; ++i) x[i] = intermediate[i] + 3;}

I don't want to restrict the blacks. I just don't want to live near them.

Who are you quoting?

How is spending months/years developing software only to give it's whole recipe away for no credit or recognition and let anyone shit on your well-worked creation more self-respecting?

They can't close the source and sell it as their own like they can with the cuck license you love so much, you cucked faggot.

from the compiler standpoint they're not even close to each other

Fucking tell me about it.

We elected Trump into office an yet this happens, disgusting.

Believed in eugenics, invaded other countries, started wars, tried ethnic cleansing, and to top it all, lost and got btfo. Yeah he did plenty of wrong things.

Back to Holla Forums you retard

Go back to reddit you gigantic faggot

You funny guy, you. Still, back to Holla Forums.

le "close the source" maymay again

It's a fundamental mistake of understanding, and you people keep making it.

You can't "close the source" of a non-copyleft free software project in any meaningful way.

Checkmate

You can do that with the GPL, too.

It doesn't matter, though. The original source is still available. It's not closed.

Checkmate.

true, but...

sure, they cannot close the source, but Apple at least can almost kill the open source project once they no longer need it

Go! Schlomo! Go out and Zapcc to the extreme!

pick one and only one

This is the most wiesely sounding thing I've read in a while.

Literally nothing about that even has any significance either since anything can obsolete anything else, it being based on an existing product doesn't give it any advantage and in fact puts it at a disadvantage since there's no real incentive to switch to the closed variant over the pre-established open variant even if it does have some new features, if they're actually worth using people will implement them in the public versions, it doesn't have to rely on the original devs, that's the whole point of open source software.

Apple specifically would never close something like Clang either, the whole benefit for them is the free contributions and testing, they lose that while gaining nothing other than more developer costs. Even if they put a cost on some license it seems like a risky move for them to make with a small profit margin. They rely on third party developers and they don't want to piss them off for no reason.

Reiterating, anyone can "almost kill" any open project by creating a better proprietary alternative, based on the original or not. It's not likely though, especially for a compiler.

There's no fact to refute, redditor. If you aren't redpilled by now you are always going to be a blue pilled reddit cuck.

So this project exists only because a profit-seeking company developed it, expecting to make some money out of its R&D.

Without the permissive license of Clang this wouldn't exist at all.

Are Clang users worse off because this product exists? Nope

Now we know the level of performance possible it's a matter of time before the Clang team figures out how and publishes a free version.

Just like how Oracle would never shitcan OpenSolaris, right? Companies do retarded shit that's not in their best interest pretty frequently.

Apple is not Oracle, just because some companies make bad decisions does not mean all companies do. Oracle and Apple aren't even in the same market either. That behavior was expected of Oracle even then, it's not of Apple. The ironic thing is that's usually something GPL supporters blast them about, as if free labor for Apple is somehow bad compared to free labor for GPL projects.

I don't think the C standard allows bar to be implemented as foo. "x" could be mapped memory (GPIO), so it could be a display, or anything.

That's what volatile is for.

No it's not. Volatile is for specifying that things change outside of how the program says they do, and so the compiler can't make assumptions about the value of the volatile variable, such as caching it.

You wish. In reality, what happens when closed forks of projects occur is that they effectively create another standard, which in the long run will become incompatible with the original. Eventually, zapcc will get different command line options and provide nonstandard preprocessor directives, and code-bases will begin to leverage these features, If enough projects become dependent on this behavior, then ta-da!, the Clang user-base is fractured in two.

I'll admit, I'm exaggerating a bit because this is just one closed fork, and its still very young.

So what if it becomes incompatible? People who choose zapcc know that they'll be using zapcc proprietary features. People who use these features do not care about clang because zapcc will be important to them.

en.cppreference.com/w/c/language/volatile

It's simple, user:
Embrace
Extend
Extinguish

As the proprietary version becomes a de-facto standard, people increasingly find themselves forced to use it. If the need to switch away arises, they won't be able to do it easily because there are measures in place to prevent exactly that from happening.

Meanwhile, the original free version lapses into obscurity and control over the software falls in the hands of those who own the proprietary fork.

And permissive licenses are bad because they enable this.

Apple's interest in clang is getting around the GPL in their own products. They don't care about how others use it and only BSD license it to trick fags into working for them for free on their project to make everything proprietary and tivoized.

If you're too new to remember (as probably all of you are), look into the history of xfree86 and all its proprietary forks like metrox, accelx, etc. and what effect they had on development.

What ends up happening is proprietary forks hire a few of the best devs of the open source version, have them work on their dead-end, then when it fails all their effort is thrown away. It would be worse if they succeeded - all the devs of the open source version would end up poached.

You're right, I don't understand how EEE works with free software which includes liberally licensed free software. I don't understand how the extinguish part of that plan works. The free version doesn't disappear and the developers don't stop working on the free version. The proprietary version may have faster release times but that shouldn't stop the free version.

These are not arguments I can agree for any case of liberal free software including Clang. I believe that has not happened this way for any case in the past.

What he fears only ever happens to BSD stuff that gets forked under GPL because it's still open enough for most devs, but code can't come back.

The code can certainly come back to them. They simply do not want to abide by the conditions of the GPL. It it their own will that prevents themselves.

Disgusting. Use "$@", including quotes.

That misses the entire point that "hijacking" projects is always cited by GPL advocates as something companies do, when only copyleft does it. You're saying to just consent to it so it doesn't hurt as bad.

>relevant developers stop working on the free version

nice autismpost

>>>/test/

test

GPL proponents shouldn't claim that proprietary companies can hijack free software. Instead they should say that liberal free software will be forked into proprietary software just as this case of zapcc demonstrated. People who fork liberal free software projects and include copyleft code aren't doing any hijacking in any way. The upstream liberal free software project are not at all forbidden to take that copyleft code and integrate it into the project - this is something that's forbidden in proprietary software. They simply refuse to do so because they refuse to subject the project to the requirements of copyleft software.

This outcome will only be meaningful if the worldwide community associated to the specific project chooses to act like helpless victims of proprietary software. People who need help developing their software ought to be responsible enough to find a skilled helper. If you can't find a friend to give you a favor, then this means hiring a skilled consultant or development team to do that same work. This is the reason why free software gives all users freedom - it's always there for you if you choose to use it. If you choose to do nothing but complain that nobody is doing your work for your benefit, that's your choice, but that's also how victims of proprietary software act.

...

All the work on the libre version will benefit the proprietary version, because the proprietary version can keep merging code from the libre version. The proprietary version will be able to use a superset of the code of the libre version, so no matter how hard people work on the libre version, the proprietary version can stay technically superior.

Unless you use copyleft, that is.

Yes that's completely true. If you believe that this is a bad thing, then it's sensible to license your free software project under a copyleft license. In the case of Clang and Apple, Apple actually believe this outcome is not an outcome to avoid.

That's because Apple is the most likely company to initiate that situation. They've already taken advantage of the proprietary licensing to initially keep Swift proprietary.

Faggot