Go is making progress there, but those that want a more mature type system will probably appreciate C# more.
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.
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.
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.
But it should at least stop growing (unless my understanding about non-moving GCs is off, which it could be).
> But it should at least stop growing (unless my understanding about non-moving GCs is off, which it could be).
As long as there isn't a bug in the GC :P. I'm currently debugging a Docker problem that looks like a bug in the GC, I'm not sure.
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.
> 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.
Well, you can try running the following testcase:
% 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.
So yes, it's a real bug that I'm debugging.
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.
So it is basically the next COBOL ;-)
(Note: I don't know anything about the Java / C# licenses. This is just talking in general.)
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'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.
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.
Sure you do. Write it yourself.
1) begrudgingly adopting a licence you don't like or want
over:
2) re-creating man years (or decades) of effort to reproduce a certain project
Especially if you lack the programming skills or money, it's not a choice at all -- you only have one option.
So in those cases you "don't chose GPL" -- you chose the project you want to use, AND have to necessarily suffer GPL too because of that choice.
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.
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.
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.
> 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.
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.)
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 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.
> 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).
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.
Good luck to you!
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 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.
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.
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".
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.
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.
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:
http://blog.barrkel.com/2006/07/fun-with-asynchronous-method...
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.
Including the APIs?
>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.