> The idea that organisations 'owe' the community copyleft software is therefore a bit foreign to me.
What do you mean? That is the very credo of free software, namely all software should be free. Hence, everybody owes the community free software. You might not agree with it, but that's the ideology behind free software.
> Google and the Android platform has equally went out of the way to isolate the platform from the effects of the GPL.
That's absolutely true. That effort is why Google didn't use OpenJDK (which is under the GPL), which led to Oracle suing them. All because Google went to extreme great lengths to avoid the GPL (they did have their reasons: they believed, perhaps rightly so, that phone manufacturers would not agree to a GPL platform).
Hence, everybody owes the community free software.
I think the credo is that developers owe the users of their software certain privileges, like access to source code and the right to modify and redistribute that source code.
What I don't like about the way the free software movement demands these rights is the misuse of the words freedom and liberty. By using these words, they deliberately imply that withholding these privileges from users is tantamount to a human rights violation.
I think that is an insult to people suffering from real human rights violations.
Ideologies are not binary -- they each have relative importance. I don't think for a second that the FSF places software freedom above human rights or even equates the two. You can be a staunch theft opponent; that doesn't mean you believe theft is tantamount to murder.
The wording they use equates the two and I don't think that is an accident. Either they believe it or they use it for effect, just like the media industry likes to call copyright violations theft.
I don't see how you can imply a human rights violation. "Human rights" are a largely technical term. It's not just rights that humans have, it's a special category of restrictions, and unless you point out the significance of that, you're not talking about human rights. The term "Human Rights" is not very good because it invites confusion. This is not the FSF's fault.
But you can't go from "you have rights" to "that's a claim of Human Rights."
You are imagining what people think and being offended by it, which is your own fault.
>I don't see how you can imply a human rights violation
By using words that are closely associated with that context. This particular article goes even further, using words usually reserved for humans (or animals) to talk about software itself:
"[...] Objective-C was liberated. [...] when and how programming language software is liberated. [...] keep the core operating system of Android liberated."
>But you can't go from "you have rights" to "that's a claim of Human Rights."
And I did not. I specifically complained about the misuse of the terms "freedom" and "liberty". I have no problems with "rights". Quite the contrary, I value my rights as a user of open source software. But they are different, less important, rights than my fundamental human rights like freedom and liberty.
>You are imagining what people think [...]
Well, you know, that's the only thing language can ever do. Make people imagine what you think.
What words do you think they should use? Don't you think the fact that they are talking about software provides enough context to determine exactly how important those rights are? Clearly they can be no more important than the software itself. So I don't know why you'd think software is on the same par as human rights, and that this'd be a problem with first recognizing the importance of software in human life.
That is, software rights can't be more important than software, and if software is critically important to human life, then software rights are human rights. And whether or not software is that important today, it is quite likely to be in the future.
>Well, you know, that's the only thing language can ever do. Make people imagine what you think.
Yeah... So why'd you quote the first half of that statement to make an irrelevant observation? Language doesn't force you to be offended.
> That is, software rights can't be more important than software, and if software is critically important to human life, then software rights are human rights.
I don't follow that logic either way. Of course you can hold the opinion that the principle is more important than any individual case. And the free software movement clearly does that.
On the other hand, there are many things that are critically important to human life, but that does not mean that specific ways of regulating them are human rights or even important.
Human rights are ends in themselves based on needs that all humans share, like the right not to get tortured. All humans do not share the need to distribute modified versions of other peoples code, even if that code runs the nuclear power plant next door. What humans share is the need for the code to be safe, but there are different means to that end.
The ability to participate in an economy in an informed and voluntary manner is a human right. That's why we tend not to practice Laissez Faire 'let the buyer beware' capitalism: because it results in blatant exploitation and in some extreme cases, slavery.
When purchasing software, the ability to view the source code is critical to making informed economic decisions. (I suppose you could have a regulatory authority that verifies software as well, but that comes with a whole other can of worms.) And unless you can build that software from source, you have no effective guarantee that the source you are looking at corresponds to the binary you are running.
>The ability to participate in an economy in an informed and voluntary manner is a human right.
I think we have worked out the core of our disagreement then. For me, not having exact knowlege of how every product I use is made and not having the right to copy, modify and redistribute someone elses product is not a restriction that is comparable to slavery, torture or imprisonment without trial. And I think people who were slaves and got tortured would agree.
There are so many things that we're not allowed to know, so many things we're not allowed to do, many of them much more important than distributing modified source code. If we start calling all of that a human rights violation, we are watering down the notion of human rights until nothing is left.
The power of universal human rights is that it is a small set of very basic things that people can agree on across all cultures and across most ideological divides. You got to think about whether or not FOSS is important enough to dilute this idea.
But again, I have no problem with the FSF fighting for the rights they fight for and I think Richard Stallman's work is net net very positive for the world. I just don't like this particular way of advocating it.
The reason why Google went with writing their own version of Java has nothing to do with avoiding the GPL and everything to do with avoiding to have to pay money to Sun.
Well, they had two options: license Sun's Java or do as they please with the GPLed OpenJDK. If they'd chosen the latter they wouldn't have needed to pay a dime. Sun/Oracle place no restrictions in addition to the GPL itself when it comes to OpenJDK (in fact, the GPL explicitly prohibits any such further restrictions). You can do as you will with it.
My understanding was that Sun (and now Oracle) had "field of use" restrictions on the JDK that prohibited it being used on mobile devices without buying a license.
I am not sure how enforceable those restrictions were, but I imagine that factored into the decision to use the Apache JDK project
That was before OpenJDK. There are a few ways you can license Java. You may freely implement it yourself, but then you must pass the TCK and abide by Oracle's field-of-use restrictions, you may negotiate a license from Oracle (Sun at the time) for their source code and use of the technology, or you can do whatever you like with OpenJDK (although to use the Java trademark you probably need to conform to some other requirements)[1]. BTW, Oracle/Sun's JDK is OpenJDK with a few advanced monitoring/profiling add-ons.
In any case, OpenJDK was released in May 2007, and Android unveiled in November later that year and made available only a year later. The reason Google used Apache Harmony was because they couldn't reach a licensing agreement with Sun and chose not to use OpenJDK because of its GPL license, believing phone vendors would reject it.
As Google probably wanted to have a non-standard edition of Java, it's unlikely that Sun would have licensed it to them (or they would have required a new standard being formalized first). Their best option was to use OpenJDK, but they didn't. They wrote their own runtime -- which, to this day, is at a great performance disadvantage compared to OpenJDK -- suffers annoying incompatibilities and is a few Java versions behind, all in order to not use GPL software.
Was Google right in thinking that phone manufacturers not have put up with GPL? I'm sure that at the time that's what the phone makers told them. Perhaps Android wouldn't have taken off if they had tried to shove the GPL down their throats. But I believe that with the iPhone breathing down their necks and no better alternative, the phone vendors would have yielded. We would have ended up not only with a much better, faster, more compatible Android, but with the most ubiquitous operating system on the planet being truly free. This also would have prevented the Oracle-Google lawsuit.
Instead, we're left with a slow OS that's years behind embedded Java, not truly open (as closed-source modifications are made by vendors), and a legal battle that some believe may have far-reaching consequences. All because people are afraid of the GPL.
[1]: For example, I believe (though I'm not sure) that IBM's and Aicas's JDKs follow the first choice (maybe the second), Azul's Zing JVM the second, and Azul's Zulu the third.
> They wrote their own runtime -- which, to this day, is at a great performance disadvantage compared to OpenJDK
This is completely incorrect. OpenJDK is absolutely not optimized for mobile and it would have been a disaster on mobile. A lot of the Dalvik runtime and libraries have been rewritten with performance and memory in mind.
You are right that Dalvik was written to be optimized for mobile, but you have to understand compared to what. Dalvik is optimized for mobile compared to simple VMs that don't have a lot of work put into them -- not compared to HotSpot. Java's embedded versions have had a lot more effort put into them than Dalvik.
Dalvik itself was plan B for Google, after they'd failed to secure a licensing deal with Sun (and didn't want OpenJDK's GPL). It wasn't anyone's first choice, and certainly wasn't some new powerful technology. Just a VM that was good enough compared to the effort that's been put into it.
There are open source (obviously) OpenJDK distributions[1] specifically made for embedded devices (although you can build them yourself), and (proprietary) editions of Java have been running on devices as constrained as SIM cards for much longer than Android exists.
You are glossing over the fact that Dalvik is a multiprocess VM. There is no such JVM, even today.
This aspect and the Dalvik bytecode are the main reasons why Dalvik is so fast on mobile. No other VM (or JVM) can realistically compete, especially not HotSpot. Not now and certainly not back then.
> You are glossing over the fact that Dalvik is a multiprocess VM.
Making HotSpot multi-process would have been a much smaller effort for Google. It really isn't that hard.
> No other VM (or JVM) can realistically compete, especially not HotSpot. Not now and certainly not back then.
I've just shown you how HotSpot embedded handily beats Dalvik. Remember, Dalvik was Google's plan B. It wasn't anyone's first choice, and certainly not some cool groundbreaking technology. It's a not-too-shabby VM for the amount of effort put into it (which isn't much), and it was available for Google to buy. That's all.
Was the is the performance difference between HotSpot and Dalvik worth $45 million in 2006 dollars?[1] Those were the alleged licensing terms proposed by Sun ($20 million upfront + 10% Android revenue capped at $25 million).
Your budget determines the kind of software you get. On a purely engineering basis, Hotspot might have been the better option, Business-wise, Dalvik made sense to Google.
I don't know, but it was certainly worth much more than the $0 they would have paid for HotSpot if they'd had the guts to go with the GPL. That's what's missing from the timeline:
* March 2007 -- Sun open sources the JDK at the perfect moment for Google to adopt it. Google chooses not to because they don't like the GPL.
I think the phone vendors would have caved. It might have taken another year, but they would have realized they had no choice once the app store opened in July 2008, as none of them could have had the brand recognition to build an attractive software platform to rival the iPhone.
I strongly suspect Android's uptake by manufacturers and MNOs would have been far less if it was licensed as GPL. So there would have been an opportunity cost to Google (that is certainly not $0).
Do you think Sony, let alone Verizon would cave and agree to the terms of the GPL? Remember this is in 2008 - Sony's DRM/rootkit scandal was only 3 years prior (2005).
Verizon doesn't make phones (I think; not too familiar with them), so what do they care? But Sony, yes, I think that when the app store opened in mid 2008, they would have realized they have no other choice but to rally around a single software platform, and one that's made by a company with a bigger brand in the software world than them. If GPL was the bitter pill they had to swallow, they would have. The upside to GPL from their perspective would have been that all of their competitors have to abide by it, too.
Also, just to clarify, the pill really isn't all too bitter. Use of OpenJDK wouldn't have dictated that all apps must be GPL -- not even bundled apps made by the manufacturer. The OpenJDK has a clear "classpath exception", which makes it more like LGPL -- any code dynamically linked with it is not required to be GPL. The only implication is that any modification they make to the actual runtime itself would have needed to be GPLed. I don't think phone manufacturers make any technologically groundbreaking, game-changing changes to the runtime -- anything that could hurt their competitiveness had it been free.
So I can understand Google's decision, and they certainly believed going GPL was an opportunity cost, but in retrospect, choosing OpenJDK would have -- at the very worst -- delayed Android's adoption by a single year, but would have ended making everyone's life much easier. I think that in hindsight, it's clear that passing on OpenJDK was a big mistake. Don't fear the GPL.
Verizon does not make phones - it sells them. It was responsible for much of Android's early success in the US with it's multimillion dollar "Droid does" ad campaign to the extent that "Droid" was synonymous with "Android".
Yes, but if Google had not been afraid of the GPL, there would have been no need for that fight. OpenJDK is licensed under GPL plain-and-simple. Google could have done whatever they pleased with that code (and would have had far less work to do, and would have had a more modern and performant runtime).
> Yes, but if Google had not been afraid of the GPL, there would have been no need for that fight.
If Android had been using the GPL, it would probably never have taken off because:
- Manufacturers and other partners would have refused to use it
- OpenJDK is not optimized for mobile, so performance would have been disastrous (especially in 2007, try to remember the kind of phones we were using back then)
I'm not sure that is the credo. At least, it's not the credo behind the GPL. Every day I use software that is at least partly GPL code, but I can't access the source code. Why? Because I used a webapp. If the software you use is running on a server rather than your local machine then the GPL says you don't get to have 'freedom'.
So "users" isn't a useful distinction when it comes to Free Software, because the GPL doesn't guarantee freedom for users. It only guarantees freedom for the person who owns and controls the hardware.
When the GPL was written, this kind of software wasn't very common. Now that it is, the FSP formalized the AGPL, which they recommend over the GPL for server-side software.
Nearly any software is potentially server side software. So really they should recommend AGPL for everything, and relicence all FSF owned projects as AGPL.
They don't because a lot of people even inside the FOSS community are violently opposed to the AGPL. Quite a few people think that it conflicts with Freedom Zero.
There is no meaningful distinction between user and developer. All developers are users, and in cases like this, with compilers, all users are also developers.
What do you mean? That is the very credo of free software, namely all software should be free. Hence, everybody owes the community free software. You might not agree with it, but that's the ideology behind free software.
> Google and the Android platform has equally went out of the way to isolate the platform from the effects of the GPL.
That's absolutely true. That effort is why Google didn't use OpenJDK (which is under the GPL), which led to Oracle suing them. All because Google went to extreme great lengths to avoid the GPL (they did have their reasons: they believed, perhaps rightly so, that phone manufacturers would not agree to a GPL platform).