With Oracle's Java lawsuits wondering if Microsoft has a chance to make a move and try to displace Java. It won't happen completely because it is the new COBOL but if they can deliver on performance and stability on Linux and other platform there might be a chance.
Go is making progress there, but those that want a more mature type system will probably appreciate C# more.
Not to sound arrogant. However I think Go (golang) is still in the hype wagon / cargo cult phase.
It's popular as in the "popular latest javascript UI/UX" sense. Not to diminish Go _extraordinary_ achievements, however it's still to early to say.
E.g. Ruby - used to be _mega_ popular, everything was Ruby at some point. Hype is over and it doesn't look too promising. Niche is taken and it stays there.
> Not to sound arrogant. However I think Go (golang) is still in the hype wagon / cargo cult phase.
I'm not going to comment on the "hype" point, since your probably right. I just wanted to mention that I found out the other day that the Go garbage collector doesn't free memory. So your process will never shrink in memory usage (on Linux it uses MADV_DONTNEED and on BSD&Solaris it used MADV_FREE -- which means that essentially the page of memory becomes an overcommitted page that doesn't exist anymore). But that still won't stop your kernel from killing it.
> It's popular as in the "popular latest javascript UI/UX" sense. Not to diminish Go _extraordinary_ achievements, however it's still to early to say.
> E.g. Ruby - used to be _mega_ popular, everything was Ruby at some point. Hype is over and it doesn't look too promising. Niche is taken and it stays there.
> I just wanted to mention that I found out the other day that the Go garbage collector doesn't free memory.
If you mean `free` as it's used in `C`, then I guess technically, it doesn't `free` memory, but I fail to see the practical difference between that and how it it releases memory back to the OS - which is does.
> So your process will never shrink in memory usage
I think you've been mislead. This statement is observably false.
> > I just wanted to mention that I found out the other day that the Go garbage collector doesn't free memory.
> If you mean `free` as it's used in `C`, then I guess technically, it doesn't `free` memory, but I fail to see the practical difference between that and how it it releases memory back to the OS - which is does.
Misusing memory overcommitment doesn't count as "freeing" memory. Sure, it happens to mean that the kernel frees the page and provides a new one in its place (which is a Linux-ism and isn't explicitly stated in the man page). MADV_DONTNEED has several quite big issues (it's worse than munmap in almost every category since it has to do an munmap immediately and then create a new page as well). The point is that the process still will get killed if overcommit_ratio is a sane value.
> > So your process will never shrink in memory usage
> I think you've been mislead. This statement is observably false.
Depends how you want to define "memory usage". I defined it implicitly as "sum of size of all mappings given to the process". In other words, how much is committed to the process. That number doesn't go down. RSS does go down, but I'm currently investigating what looks like Go not reusing "unused" pages properly.
% for i in {1..1000}; do docker run -dit --name shell_$i busybox sh; done
% for i in {1..1000}; do docker rm -f shell_$i; done
You'll notice that /proc/meminfo shows a large amount of overcommited memory. If you look at pprof output from the daemon, there is nowhere near that much memory being used (so it's not a goroutine leak or something like that). If you then re-run the first command the memory still rises, which shouldn't happen because it has ample unused heap space.
> Not to sound arrogant. However I think Go (golang) is still in the hype wagon / cargo cult phase.
Well, you came off sounding kind of arrogant. I'm not sure what this has to do with the discussion. There are many valid uses of java that can be done in go, regardless of its popularity. There are many valid uses of java that can not be replicated in go, regardless of its popularity. You can swap out that criticism with pretty much any language built in or after the 90s and it's still just as valid.
I mean, feel free to critique—it could very well be at its peak popularity and cannot take ANY MORE java marketshare—but this still requires argument.
Java is far far from the next COBOL. It is still my first choice when I want to choose a technology that will run for the next 20 years with minimal amount of code maintenance.
Seriously? That sounds like the perfect job for Common Lisp (which appears more or less set in stone in 2016, albeit without the usual concomitant stagnation, given its malleability).
Plus, in fact, I get the distinct impression that your second sentence describes what COBOL actually did for companies decades ago, so the first one makes it sound like a contradiction.
Actually, while unorthodox, I think one could read that sentence so that it refers to COBOL; as in "COBOL is still my first choice..." -- implying java will never be as good/stable... ;-) (No, I do not think that's what gp meant -- unless you're right and it's meant as irony).
C# is not different enough to Java to warrant the effort. There would need to be a killer differentiator, something only C# can do, and Java can't. Cross-platform including iOS might be it, but it's a bit of a stretch. I don't see C# displacing Java where Java is currently used in server-side development.
Licensing could be enough alone. We're auditing everything we use for license issues because we don't have to get bit by the GPL and have to opensource all our proprietary software. Even if C# was noticeably worse (for some arbitrary definition or worse), if it had a more permissible license, that alone could draw people to it.
(Note: I don't know anything about the Java / C# licenses. This is just talking in general.)
> get bit by the GPL and have to opensource all our proprietary software
The tone here sounds very angry. You aren't "bit" by the GPL, you choose to participate in the usage of the license and the community of code that comes with it. It's not some unknown, nasty thing you need to constantly defend yourself against (as implied by "being bit" like it's a dog you need to watch out for everywhere).
"We're auditing everything we use for license issues because we activly choose not to participate in the GPL community and would rather abuse and profit from other people's good will" is closer to realitiy
It would be trivially easy for an engineer to add a GPL-licensed dependency to a project without realizing it, perhaps via a transitive dependency, thereby causing the company to be in breach of the GPL.
If you don't audit, you don't know if you are in breach of the GPL or not. Your corporate counsel will want you to audit. You can't reasonably take any action, including open sourcing your project or even posting code snippets on a company engineering blog, until you know which licenses you actually use.
Its about as trivial as for a web developer to accidentally use a proprietary image they found on the web, a game developer that use the unreal engine, or a marketing using someones music in a commercial.
Its quite common to find commercial copyright infringement in all of those (except for the unreal engine, since I don't know publicized case of that), and there are artists who earn a fair income by contacting infringes and demand payment or a cease and desist. I wouldn't however describe that as being bitten by the rightful author, but put the blame on the developer who is using someone else work without permission, especially if they their own business model is based on copyright.
> It would be trivially easy for an engineer to add a GPL-licensed dependency to a project without realizing it, perhaps via a transitive dependency, thereby causing the company to be in breach of the GPL.
Just as easily as it is for a designer to use a copyrighted work. The GPL isn't a boogieman, every project that's under the GPL says so. If a developer isn't mindful enough to realise that they shouldn't randomly copy-paste library dependencies without knowing anything about them isn't a very good developer.
Try running mvn:dependency-tree on any large enterprise Java project, and see what comes out. If you told me you were familiar with every single library in the output, I would not believe you.
> If a developer isn't mindful enough to realise that they shouldn't randomly copy-paste library dependencies without knowing anything about them isn't a very good developer.
That's a logical fallacy called: No true Scotsman. In this case - Good developers can be good at some things but bad at other things, so there's absolutely zero correlation between "good/bad developers" and "people who remember/forget to think about licensing".
If you don't consider the GPL to be boogieman, how do you feel about predatory lenders and loan sharks? All of them are just agreements...right?
In a predatory lending/loan sharking scheme, the lender offers their product (money) to people who need it (borrowers) who must agree to extraordinarily high interest rates.
This seems very similar to the GPL since it's just a software agreement that includes extraordinary clauses for developer who "borrows" the product.
It's not just that corporate counsel will want you to audit. I worked at a company where I found a GPL violation and wanted to comply, but if we started complying with the GPL it would have shown that we knew that we previously hadn't been complying, so I was told to not comply. Ugh. Just for redistributing a couple binaries, there were no libraries involved.
A few days late on the response here, but I'm going for it anyway.
I was using "bit" colloquially, and my tone wasn't angry. We "choose not to participate in the GPL community" because we sell software, and if that software could be requested for free, we couldn't exactly stay in business trying to sell it. I have nothing against the GPL, and I'm pretty certain the management and rest of engineering don't either.
In fact, I/we aren't trying to abuse and profit form other people's good will. That's why we check the licenses of software/libraries we use: to respect the way in which it was licensed. We have to keep our software closed source, so we obey the licenses that could require us to make it open source.
>The tone here sounds very angry. You aren't "bit" by the GPL, you choose to participate in the usage of the license and the community of code that comes with it.
It's not like you had a _choice_ if there's software you want to use and it's only available as GPL.
You'd have only chosen if there were 3-4 license options for the same software, and you went with GPL willingly.
> >The tone here sounds very angry. You aren't "bit" by the GPL, you choose to participate in the usage of the license and the community of code that comes with it.
> It's not like you had a _choice_ if there's software you want to use and it's only available as GPL.
You can either write it yourself, don't implement that feature or comply with the GPL. The GPL would be a pretty bad copyleft license if companies could just ignore it because "we want to keep our stuff proprietary".
The authors of the software wanted to ensure that all users of their code would have perpetual freedom. Complaining about it without recognising their reason for using the GPL is quite a selective argument. They don't want you to use their code if it means that you'll take away your users' freedom.
Except that "perpetual freedom" for one group (users) also equates to "perpetual removal of freedom" for another group (developers).
It doesn't seem fair to mention one without the other, since the latter is the primary reason why many, many developers choose to not use the GPL.
Also, I don't see how the person who said they don't want to get "bit" by the GPL is "Complaining about it without recognizing" anything? To begin with, it seems completely subjective.
I can feel totally "bitten" by the fact that I only have one choice of cable company in my area, even though their monopoly is totally legal...but I didn't agree to any of it. Similarly, no developer really has a choice but to use GPL software if they want to live in the Linux neighborhood. (But they shouldn't complain according to you because they have the "choice" of going off on their own to re-build 20 years worth of core Unix utilities.)
> Except that "perpetual freedom" for one group (users) also equates to "perpetual removal of freedom" for another group (developers).
Only if you redefine the word "freedom". Both developers and users have the same four fundamental freedoms. The only difference is that the developers don't have the "freedom" to enslave their users. But that's like claiming that you don't live in a free society because you can't enslave people -- just because you don't have the "freedom to enslave others" doesn't mean that you don't have freedom.
> Similarly, no developer really has a choice but to use GPL software if they want to live in the Linux neighborhood.
Nobody has actually explained why this is a bad thing. Is it because "developers don't want their users to have freedom"? Many companies exist that sell GPL software, so it's not a monetary thing. And your cable company analogy is flawed because the GPL doesn't force you into a monopoly.
And, by the way, not all software in the "Linux neighbourhood" is under the GPL. So that's an unfair exaggeration (although I do honestly wish more of it was).
> But they shouldn't complain according to you because they have the "choice" of going off on their own to re-build 20 years worth of core Unix utilities.
If they don't want to contribute to a community that values user freedom, then they won't be welcome in that community. I don't understand why someone would be surprised by this.
No. The GPL removes my freedom to sell something that I've created.
> The only difference is that the developers don't have the "freedom" to enslave their users.
This is where I think your entire argument falls apart: Offering users the choice to buy my software is not enslaving them. If it is, then so is the GPL because it's a choice that users can buy into or not...just like the choice that the GPL offers to developers.
You can't have it both ways. If commercial software "enslaves" users by simply offering the users a choice to buy the software, then the GPL must also be enslaving developers by simply offering them a predatory contract.
> No. The GPL removes my freedom to sell something that I've created.
That's patently false. Many companies (SUSE and RedHat come to mind) sell free software. The only difference is that you can't create a monopoly of experts in the software you wrote. The business model of free software works through selling support (such as L2, L3 and developer support that can implement features and fix bugs much faster than upstream would).
> This is where I think your entire argument falls apart: Offering users the choice to buy my software is not enslaving them.
The GPL allows you to sell software. That's not how free software works. I believe you may be confused by the word "free". In this context, it refers to freedom, not price. There are quite a few companies that sell free software, and it's disingenuous to claim that they don't exist.
> If commercial software "enslaves" users by simply offering the users a choice to buy the software
Proprietary software, and the choice to "buy software" has nothing to do with the free software movement. Again, free refers to freedom. There are several commercial free software companies.
Proprietary software enslaves users by making them helpless against a developer that may mistreat the user (and the user can't do anything about it).
> Proprietary software enslaves users by making them helpless against a developer that may mistreat the user (and the user can't do anything about it).
I find your propensity for double standards amazing. These so called "enslaved users" made a choice to buy into the developers proprietary software. It's the same exact thing as developers buying into the GPL.
So, if proprietary software is enslaving users, then the GPL is most definitely enslaving developers.
You can argue semantics all day long....but you'd still be wrong. But anyway, I'm glad that next to nobody releases new software under GPL anymore and that the vast majority of developers prefer a license like MIT that doesn't enslave developers at all.
"The GPL removes my freedom to sell something that I've created."
No it does not. You can still sell the first copy, technically and practically. You can still technically sell licenses - it is just practically made difficult because those you sell the work to can share it.
> It's not like you had a _choice_ if there's software you want to use and it's only available as GPL.
Sure you do; if you don't want to accept the GPL license terms, you can write your own software that fulfills whatever function you wanted the GPL code for.
Have you considered why the original authors chose the GPL? It's so people who use their code will never take away the freedom of users of the code. If you're complaining about not being able to take their code and make it proprietary, you're missing the point that THAT'S WHY THEY CHOSE THE GPL.
That's orthogonal to whether the prospective user of the package has an actual choice or not (besides using as GPL it or going without).
WHATEVER THE ORIGINAL AUTHORS' REASONS FOR CHOOSING THE GPL (sic), it doesn't change the situation that one might not be happy for a project they want to use being in GPL -- including people who don't intend to make it proprietary, but who prefer BSD licenses nevertheless.
> That's orthogonal to whether the prospective user of the package has an actual choice or not (besides using as GPL it or going without).
You've just outlined the choice that the person has. Admittedly, I wouldn't use the GPL for libraries, I've started using the MPLv2 for stuff like that. I don't really agree with the common reading of the combined work clause in the GPL wrt libraries (a work that uses a library's API shouldn't be bound by the copyleft of the GPL IMO -- but as Oracle has proven, APIs appear to be copyrightable).
> WHATEVER THE ORIGINAL AUTHORS' REASONS FOR CHOOSING THE GPL (sic), it doesn't change the situation that one might not be happy for a project they want to use being in GPL -- including people who don't intend to make it proprietary, but who prefer BSD licenses nevertheless.
BSD licenses allow distributors of the software to make it proprietary. That was clearly a more important problem to the author and community of the software than allowing GPL-incompatible projects to use the code. It's a fundamentally ethical decision, which you may disagree with if you follow the open source (as opposed to free software) philosophy.
You're missing the point. He's saying that there's technically a choice, yes. You agree on that.
The part you seem to avoid agreeing with is that it can often be a really annoying choice to have to make. Isn't everybody entitled to be annoyed when they only have one so-called choice? (Like having to move or use slower alternatives in order to get away from Comcast as your ISP.)
Continually pointing out that there is technically a choice doesn't really help anyone who feels bitten by their lack of choices.
You don't get the right to be annoyed when you have to comply with the license terms of something that you haven't had to spend time working on (and usually get without paying for it).
I first started using C# professionally in 2003, after starting out with the betas. I helped implement some key .NET support for the Delphi compiler when I worked at Borland.
I'm quite familiar with the evolution since then too. For example, back in 2006, I advocated implementing a CPS transformation to make better use of async code in .NET:
It only took 7 years for async methods to come out, but they're there now; and I understand their utility in no small part because I was one of the people asking for them.
Why? The license problem is only related to the oracle java implementation. The OpenJDK implementation has not any related problem, and, honestly, performs already far better than the oracle one (and I think it will improve even faster now that Google will use it for Android).
OracleJDK is just OpenJDK plus a few propriety bits like Web Start and Web Plugins, (and I think Java Flight Recorder). OpenJDK is the reference implementation since Java 7.
Source: http://openjdk.java.net/faq/
>Is Oracle JDK based on OpenJDK?
>Yes. Oracle JDK is based on the OpenJDK source code. In addition, it contains closed-source components. The final result is licensed under a Binary Code License.
Except the problems is many projects I ended up building would recommend and claim support only for Oracle downloaded JDK packages. Some explicitly claimed they do not supposed OpenJDK, claiming stuff would crash or be slow in that case.
It is the entrenched, default back-end business language. It will be running on servers for the next 30 years. 30 years from now, there will be job posts wanting "Java developers to maintain microservice/agile/tdd-based services" because all the Java devs will be retired and everything will be programming by thinking about algorithms and transmit it directly to the compiler via a brain implant.
Yes this is correct. The worst part is currently the mono version Unity uses has a 'stop the world' garbage collector, the worse kind for a game as at 60 fps allocations quickly add up and the game can constantly freeze frame. The hoops you have to jump through to work around this make for some ugly code.
Yes, and it's a huge pain! We have to pool game object instances, and sometimes even have to attempt to force GC to prevent things from freezing every few seconds.
I've got a little secret: We do the same thing in native code.
malloc() and free() can be almost as expensive as a GC in aggregate(it's a matter of paying the cost at creation vs GC time). Pooling is a really nice performance tool, just requires a bit of hand tuning to the scenario.
Pooling has a lot of nice properties, like data locality that games can benefit from greatly especially in situations relying on tight loop like calling update on every game component or particle.
It's really not that different from how games written in languages like C++ are implemented though. It's impossible to avoid the object pooling idea if you want maximum performance.
That's horrifying. Is there any way to disable the GC and manually manage memory? I don't remember if the C# spec supports this, because it's been years since I've written in it (and Mono didn't exist back then).
So there is... using the "unsafe" pointers and fixed keyword, etc. The Unity interfaces don't support that, though, so for things like dynamically updating textures and vertex data, you're pretty much stuck with GC.
You "disable" the GC in Unity by never allocating anything new after initializing the game. It's a great learning experience to update code to this and it's practically required for mobile.
There was a Squeak based game emulator/debugger shown at one Smalltalk Solutions. The developer talked about doing tricks, like turning off the GC. You'd know which objects were persistent, and which weren't, and at the beginning of the game tick, everything that wasn't persistent was assumed to go away. No scanning the heap at all.
That could have even been a factor in the decision. Microsoft wants people to use C#, but one of the most popular C# platforms (Unity 3D) is stuck in the dark ages, so to speak. Even conservative enterprise .NET shops probably have better tooling and workflows than your average Unity developer starting a new project. At least Unity bundles Visual Studio these days.
If this thread WAS about Windows (and not Unity), I have a feeling that the steam hardware survey is not a good indicator of how many potential C# users are using Windows. Maybe something like the Stack Overflow survey would be better - http://stackoverflow.com/research/developer-survey-2016#tech...
50% are Windows users according to that survey. Still a significant amount for sure, but not really the same thing as 95%.
I think about this and then think about what happens when you let a supplier drink of your milkshake. Which is when they use control of something you depend on to demand a share of your profits. It's worth money to not to be in that situation.
Hm? Wasn't it already dual-licensed MIT and GPLv2? I guess they just got rid of the GPL option? What's the point if it was already dual-licensed?
edit: Oh, I see. They used to sell LGPL exceptions for the library and GPL exceptions for the tools. I guess they have decided to stop selling exceptions and just give everyone an exception:
Seeing how they were already able to sell exceptions, they must have been sole copyright holders, so they should have no problem changing the license of everything.
I think (L)GPL has reached a point where in most cases it is self-defeating. It does not encourage adaption in the same way for example MIT does. This means that copy-left becomes a moot point. Open-source is happening (just look at Microsoft for example). But it's happening not so much thanks to GPL, but rather despite it, out of the realization that we all have something to gain by sharing. IMHO GPL hinders sharing because it puts a lawyer between the developer and the code.
Sorry, but I'm far from an opensource zealot, but I think you should give the GPL license more credit than that. V2 brought opensource to the masses with Linux and the entire ecosystem/toolset that comes with it.
GPL doesn't hinder sharing. GPL hinders proprietary software. Now, if you don't believe in the morals behind the free software movement, then you might decide that hindering proprietary software is hindering "sharing with companies". It's a very odd kind of sharing to give something to a company and they make it proprietary so they don't give anything back and end up also mistreating their users.
A bit late maybe, but GPL does not only hinder proprietary software, it also prevents the use of a more permissive license, such as MIT. Personally I would never GPL any of my code because of this. I prefer a more permissive license (such as MIT or similar) but that also means I cannot put GPL code inside my code. So whenever I see GPL:ed code, whether for private (open-source) purposes or business (proprietary, closed-source), I steer clear. So if I'm not able to use the code for any purpose, does that not mean that sharing is hindered?
Btw, I never said I don't believe in the morals of the free software movement, I just said I don't believe GPL is the way forward. GPL is idealistic but not very pragmatic. Open-source is the future and (ironically) a lot of big (traditionally closed-source) companies are paving the way.
When discussing highly biased points. It is always wiser to be able to acknowledge that even your bias, is the cause of some sorrow. However, despite that, it is still worthwhile.
I appreciate your passion for the free software movement. But remember that in any conversation you do yourself and your position a disservice by brushing off practical criticisms for theoretical ideals.
MIT is a more business-friendly license, but it also reduces the risk of lawsuits tremendously for companies who might decide to become part of the ecosystem for a project.
Consider that Apple is still using the oldest GPLv2 version of bash on OSX.
While this is a blow to Stallman's goal, I think it's a step in the right direction for broad corporate acceptance of the benefits of open source.
I wouldn't say that's the least you can do. That's actually coming quite close to the most that would do.
I think it's a little disingenuous for you to reframe Stallman's viewpoint as 'basic human decency' since it implies that anyone who disagrees isn't a decent human being.
It being basic human decency is actually an argument against the GPL. One of the worst things you can do is make basic human decency a legal obligation. If every time someone did something nice for me, I was worried about now having a legal obligation to do something, the world would be a much worse place. Basic human decency should be freely given and freely received with no legal obligations. Let karma decide about basic human decency, not the courts.
On the other hand, most crimes also go against basic human decency, so something being basic human decency is not always an argument against it being a legal obligation.
That is a common argument on why copyright should not exist. Every time someone do something nice and want to share their favorite song or movie to me, I am told by society that they are doing something wrong and I have a legal obligation to decline. Its crazy, basic human decency should be freely given and freely received with no legal limitations. The courts should not be involved.
This is not an analogous situation. With open source or basic human decency, I am sharing something that I have a right to (either code I created, or my time/energy). It is not basic human decency for me to give your money away without your consent to someone else.
If you consider that copyright is equal to someones money, you should really respect their choice in what situation they are consenting to have it getting shared!
But why did you say that the world would be a worse place if every time someone did something nice to you, you would have to care about the legal obligation of that act? You either respect that authors has copyright, or you don't. I could never respect someones opinion if they thought that only
their copyright is valid.
> Forget Stallman. It's basic human decency. If I benefit from someone else's work, the least I can do is let others benefit from my work as well.
"Basic human decency" is not an argument against the GPL. Have you considered why people use the GPL? It isn't to stop companies from using their code, it's to stop people from making the code proprietary. There's no clause in the GPL that says "No companies allowed, lol." Companies can (and do) benefit from the work of people who put their code under the GPL.
Just because I care more about assuring the freedom of my users than the "right" of a company to make proprietary software using my code doesn't mean that I don't have basic human decency. I'd argue the opposite, I just don't have basic corporate decency.
> "Basic human decency" is not an argument against the GPL.
He was arguing for the GPL.
> Have you considered why people use the GPL? It isn't to stop companies from using their code, it's to stop people from making the code proprietary.
That's one reason. Another reason is that they have no choice to choose GPL since maybe they're building on a GPL system.
Another entirely different reason people choose the GPL - to keep customers paying for their services.
Some people also choose the GPL because they just do whatever their peers do. There are lots of reasons, not just the one that you stated.
Also, I would argue that "making the code proprietary" is a very inaccurate phrase. If I take your GPL code, make some changes and then sell it without providing the source code, am I making your code proprietary? No. Because your code is still available. I'd be making a derived work proprietary, not the original code.
> > "Basic human decency" is not an argument against the GPL.
> He was arguing for the GPL.
Whoops, I guess it was too subtle for me. :P
> Another reason is that they have no choice to choose GPL since maybe they're building on a GPL system.
Fair point, this is what happened to GeoGebra (which has a GPLv3 core, but all of the other stuff is proprietary -- which makes packaging it quite tricky and they seem to contradict themselves in their licensing documents).
> Another entirely different reason people choose the GPL - to keep customers paying for their services.
How would that work? Do you have an example? I would assume that since the person has a program that is under the GPL, they have no obligation to continue paying anyone (unless they require support they cannot do themselves -- but even then they don't need to pay the vendor they can pay any developer).
> Some people also choose the GPL because they just do whatever their peers do.
This is a fair point, but I'd hope the peer pressure is accompanied by some explanation of why that group decided to use the GPL. That reason may or may not be because of user freedom, but at least it would make the developers less like lemmings.
> There are lots of reasons, not just the one that you stated.
I'd argue the other examples are in the minority, but I may be wrong (since I don't have any evidence to back up that assertion).
> Also, I would argue that "making the code proprietary" is a very inaccurate phrase. If I take your GPL code, make some changes and then sell it without providing the source code, am I making your code proprietary? No. Because your code is still available. I'd be making a derived work proprietary, not the original code.
A proprietary fork is still a proprietary version of a free program. Sure, you might argue that since it's a fork it's "less bad", but if the proprietary fork becomes more popular than the original it's an overall blow to free software. Not to mention that that would be a GPL violation.
GPLv3 has a lot of provisions concerning how companies may/may not litigate patients. Apple's legal strategies don't allow them to comply with those requirements.
> GPLv3 has a lot of provisions concerning how companies may/may not litigate patients. Apple's legal strategies don't allow them to comply with those requirements.
In regards to the particular piece of software being licensed. The patent provisions are akin to a copyleft Apache 2. Since companies are very happy to use the Apache 2 to avoid lawsuits I'm (not) surprised that they don't want to extend the same protections to their users with the GPLv3.
Not if they requested the contributors to sign the Contribution License Agreement (CLA) before accepting their changes.
Or, the other way (although I can't guarantee that this is true) would be to choose a compatible license with the one they were using before. Compatible license scenario basically means that the license changes are small enough so that they don't have to request from people to agree with the change.
No, because they signed CLAs. And this is yet another reason to not ever sign a CLA for a free software project. You never know if your code will become proprietary (especially if it is a copyleft license). Sadly, this is also why I'll never contribute to GNU projects.
You're worried that a GNU project will relicense code in a way that allows proprietary software? I mean you're not wrong -- they technically could do that but you honestly expect them to?
Well, it's more about what happens if something bad happens to the FSF? What if they get acquired and then $BigCo gets all of the copyright assignments. I don't believe that the FSF would betray people like that, but there may be situations where they don't have a choice.
This is an unlikely scenario. The FSF is a 501(c)(3) charity, which means they have to work for the benefit of the general public and not to give an advantage to any particular person or for-profit company. If they would ever do the latter, the following IRS audit would not be fun.
Many proponents of copyright assignment to for-profit corporations have argued that "it's just the same thing as what the FSF does, so it's fine", but their legal nonprofit status makes it a substantial difference.
A better argument against the FSF's copyright assignment practice is that it is bureaucratic overhead for somewhat questionable benefit.
I've actually discovered since that the FSF's CLA actually explicitly states that you give them your copyright under the condition that they always provide it under a copyleft license. So it looks like I was wrong about that and might even start contributing to GNU projects.
Off-topic, but knowing that Nat and you met (from what I recall) while interviewing for a position in Redmond and then went off to create GNU's COM (GNUNetworkObjectModelEnvironment) which became a desktop, what is it like landing at Microsoft after all those years? Final destination?
Nat and myself knew each other for a couple of years before that. It is only that we first met in person for the first time when he was an intern, and I was interview for a position on the IE team at the time.
We are joining a new Microsoft, with a team that is highly energized to give developers the tools they need and in particular, we are happy to be joining forces in their development efforts for .NET. With .NET Core about to be launched, there has never been a better time to get into C# and F#.
Did this cause any problems for third party contributions to mono? Did everyone agree to have their work relicensed? There's well over 400 contributors to mono.
Mono was always designed to be dual-licensed, because we needed a way of monetizing the investment.
Because of this, the LGPL and GPL portions of the code required either copyright assignments, relicensing rights, or the contribution to be made under the MIT license.
This is how we built a business that allowed us to dual license the runtime for many years.
They are completely different licenses. Read the text and decide on the license if you like it. CC0 is effectively the closest we have to international public domain.
I would argue that WTFPL[0] is also fairly close to being a public domain, right there next to CC0. Even FSF recognizes it as a valid (but not a recommended) license[1].
The difference being that large bureaucratic organizations need an army of lawyers to approve the use of open source libraries, and using a common license that is already understood (e.g. CC0) will result in a far smoother experience when the developers in that organization try to use anything to make their miserable lives a touch nicer.
source: I have formerly lead one of the described miserable lives.
MIT requires attribution / preservation of the copyright notice in both source and binary redistributions. It's rather more like CC-BY (although CC-BY is fairly strong, and has a "no additional restrictions" clause, it seems...).
MIT is all-permissive and compatible with everything. Roughly the only reason to use CC0 instead of MIT would be if you don't want to require people to preserve the copyright and legal notice itself, which may be appropriate for small code samples where even that might be mildly onerous.
I would love to try to hack on that to try to get a cross platform GUI toolkit that's similar to WPF.
Silverlight was a great peace of tech with a ton of stuff developed for it (widgets, testing tools, libraries, etc.) having that as a cross platform GUI framework that works on windows/linux/mac and ios/android/wp would be amazing and is doable - for simplicity you could strip out the codec parts, DRM and stuff like that, implement rendering on top of OpenGL ES and do platform specific input handling.
LGPL kind of makes phones a no-go so I would like to see if it's also covered in this switch before spending time on it.
I wonder what your thougts are on this - personally ofc. - you probably thought about it at some point given your work on moonlight and xamarin. Even the MS implementation was ported to osx, you could strip codec/DRM stuff - you could get a fully featured GUI toolkit native to .NET - a lot of work went in to that before Microsoft pulled the plug - now that it's laying dead and new MS OSS trend it doesn't seem that far fetched that they could OSS it.
Could I suggest you take a look at my project, Perspex?https://github.com/Perspex/Perspex - it sounds like it ticks your boxes and we're always in need of contributors!
anyone care to explain the difference/relation between mono and the open source .net core
are they the same thing /
do they complete each other /
do they overlap
.NET largely only exists for Windows/OSX, or at least Microsoft Supported Platforms.
Mono was started by Novell, later Ximian starting working on. The goal was to build a C# compiler and compatible runtime for all platforms (PS3, Xbox360, wii, Linux(SPARC/IA-64/x86_64/x86/PPC/MIPS/ARM), Mac, FreeBSD, Solaris, Android, and iOS).
dotNETcore is the Microsoft implementation of .NET which supports OSX, Windows, Linux. dotNETcore vs Mono is more or the less same as OracleJVM vs OpenJVM (except they're both owned by the company). They use different JIT's. Microsoft built their own. Mono uses LLVM
Mono was not started by Novell. Miguel originally worked on his own with volunteers on a purely open source project. Miguel later pulled the mono dev team into Novell and started a commercial development side with SuseLinux. When that partnership was desolved, Novell gave everything to Miguel and he created Xamarin.
Mono was started by Miguel at Ximian, and most of the Mono code was owned by Ximian. Ximian was bought by Novell and with it, all the Ximian-owned Mono code. (I don't remember if a CLA was required before or after Novell bought Ximian.)
The Novell-owned IP was either sold or licensed to Xamarin later.
Joe is correct, the code was always owned by Ximian.
And we did require copyright assignment or relicensing rights from the start to support a dual-licensing business. It was the One Blessed Business Model endorsed by Richard Stallman at the time.
It's also worth mentioning, even though there haven't been any official announcements, that it's almost certain that Mono and .NET Core will merge into one runtime, or more accurately .NET Core will continue the cross-platform work that Mono started.
Maybe when mono first hit, using a 2 clause BSD would have helped them win share. But now? I don't see anyone switching now because they switched to a free'er license. You either liked using it before because of the lgpl or you smelled the lgpl and ran away to use something else.
At this point in the game I don't think it matters much.
I think this is great, I wonder if this means Microsoft is going to (I'm not sure if they already do and have) contribute directly into Mono itself, which would be really fantastic to finally see Mono support more of .NET's core features. I would love to see the day where I could compile a C# (or potentially VB.NET / C++/CLR) application on any OS with Mono available to it, just as I can on any machine with Visual Studio / .NET available to it. Then we could see a serious competitor for Java. .NET already has things like NuGET which would be amazing to see all those projects just run on Linux without effort.
Neat. C# looks more attractive day by day. Is there a decent non-commercial AOT compiler for it (I know that Mono has one, but not sure whether it's any better than GCJ was)?
I actually sent him an email about this and asked for his opinion (as well as ask a few questions about CLAs in general). I'll post the response here if it's interesting.
His response was fairly short. However, I learnt something I didn't know -- the FSF CLA actually requires that the FSF will always maintain your contributions under a copyleft license. They also provide recommendations on how to make contributions to projects that require CLAs (such as negotiating similar terms for the project).
Here's the complete contents of his email:
---
[[[ To any NSA and FBI agents reading my email: please consider ]]]
[[[ whether defending the US Constitution against all enemies, ]]]
[[[ foreign or domestic, requires you to follow Snowden's example. ]]]
This doesn't change my views on the general issue of assigning copyright to free software projects, which I stated in http://gnu.org/philosophy/assigning-copyright.html. There are sometimes good reasons for license changes.
Is this an attempt by Mono to battle Microsoft's open source Roslyn compiler and upcoming cross platform '.net core' I wonder? Those two technologies could make Mono irrelevant in the future.
Go is making progress there, but those that want a more mature type system will probably appreciate C# more.