Not buying Sun was the mistake. $7B is all that would've taken (less if they sold the os and hardware division) to make the computing world a better place.
Not necessarily. If the judgement that APIs are not copyrightable is upheld (which is a big if), the computing world will be a better place than it would be if Google had managed to avoid the question.
7B is pocket change to them, completely agree. I was shocked to hear they let it pass iirc. I figured they were playing hardball and it just blew up in their face.
Or did they make the right decision? Just because they have the money doesn't mean they need to spend it. Did litigating cost them 7 billion? The legal win shows they made the right choice in not spending 7 billion on what they are allowed to use for "free".
IMHO you're over simplifying. Oracle was better positioned to capitalize on Sun assets, so they were likely to pay more than Google. Microsoft or Apple may have decided to bid to prevent Google from acquisition. Merging with a huge enterprise is always painful.
I'm not so sure given the results. Google (with selling the hardware / chip division to Fujitsu) would have done pretty well given all the tech projects Sun had.
If Apple had bid to prevent (patents I suppose), I wonder if ZFS would have finally been on OS X. Java would have been the truly odd man out in that acquisition. I could see Java being sold to IBM.
While you're obviously right (Oracle _did_ pay more that whatever Google offered (if anything), in retrospect perhaps blinkingled's assertion that $7B might have been a reasonable amount for Google to have offered seems at least arguable. In one sense perhaps you are oversimplifying - sure Oracle was in a better place to use some of Sun's assets, but Google is clearly now in a dangerous place having a competitor like Oracle owning major parts of technology Google's mobile strategy depends on. Whether that's seven billion dollars worth of danger I have no idea - but I suspect there are people at Google regretting the decision _not_ to buy Sun (or more specifically, buy Java and get all the rest of Su for free) back when they had the opportunity.
Google is basically a java shop. Are you saying they are unable to capitalize of Sun assets ? they choosed java as Dalvik first class language , what more do you need to capitalize of Sun's asset. It is a mistake and google will pay a huge price in the future.
If they had to redo it today, what could it be instead?
* Javascript -- I hate the language, it has enough warts to make it unpalatable
* Dart -- I can see it, that would be great, still kind of new though
* Python -- I understand they could have done it, but it was a political decision not to (at least according to Guido's remark during one of the PyCon's), performance might not be up to par on some devices
* Go -- too low level perhaps, but it would be cool
Go, C/C++, but in the ideal world- Python (they would have to very seriously tweak the interpreter)- imagine how easy app creation would have become with Python? They would have a huge advantage over iOS by lowering the entry thresholds for developers.
Python is neither fast enough or robust enough to use as the foundation for an OS. You need static typing and strong tooling both for performance and for correctness. Those that disagree with this need only point me to a successful counter-example.
Google has modified Java for Android. They could have instead modified Python. There have been academic papers that have shown that Python can be made to be statically typed (ignoring one or two keywords, like eval).
Assuming that Google had done these, there should be no reason that Python would not be fast or robust enough.
Yeah Guido was basically asked this at a PyCon in the past. He was working for Google and at some point he probably had brought up the question. Someone in the audience asked about it and his comment was that it was "political". In other words technically possible but powers that be decided against it for other reasons. It is also important how he said it, he was very calm before and after, but when answering that question he was visibly upset. You could tell it was a sore topic for him that made him pretty angry.
LuaJIT may make the performance of Lua better or even just acceptable in some cases, but it does nothing to help ensure correctness. Correctness is almost always more important than performance. It most cases it is useless to do something quickly, but to also be doing it incorrectly.
The advantage the DVM has is it's a baseline that developers can work with instead of worrying about hardware.
This was probably very desirable to Google in 2005 as it gave them the chance to court mobile manufacturers with the promise that their operating system can be deployed across a range of devices and theoretically all apps etc should remain functional, regardless of hardware as it's the VM that's the deployment target, not the phone.
Remember that back in those days the mobile OS world was god awful, Symbian was abysmal, JavaME was broken and Windows CE....well let's not go there.
Did they really have to pick one language to rule them all?
It seems odd to me to design a platform that only supports one programming language. What happens when people find better ways of expressing their intent?
I've thought this myself lately but what alternatives did they really have? The only other real alternatives are C++ and C#, which are both problematic for different reasons.
I wouldn't mind seeing a new mobile OS build around Go but it's way too late for a change that fundamental for Android. For better or worse Java & Android are married now.
I'm not a huge fan of JavaScript (to say the least) but I'm not joking either. Most Android apps aren't exactly "software egineering at scale". Certainly no more so than a modern web app.
The first Dalvik versions didn't even have a JIT, so performance apparently wasn't the main concern. They could have added optional static typing to their JavaScript VM as well.
I think Google chose Java because many people know it and because the Java faction inside Google is powerful. But many people know JavaScript as well, and arguably the typical Java developer isn't exactly a UX guru. So JavaScript would have been a better fit for Android even though I (and you) don't like it.
Actually a lot of apps are every bit as complex as a typical desktop app. I'm not sure if you've done much app development but many of the apps I've worked on have been pretty large.
Unless you propose writing the entire OS in JS then there's also a huge advantage in using the same language for core OS and APIs and for application development.
In any case as some of the more modest Java replacements like Xtend and Kotlin mature I expect to see Java the language recede in importance for Android.
Sure but the bulk of the code above Linux + userland is Java and all the APIs are Java. In hindsight it might have been a better choice to just buy Mono but that ship has long since sailed, for better or for worse.
> Sometimes I think the only difference between Oracle and SCO is scale.
Whenever you think that you should probably read up on both Oracle and SCO.
SCO was a dying company that tried every dirty trick in the book to blackmail the world into giving it a free ride to newfound riches based on ridiculous claims. SCO was backed behind the scenes by Microsoft simply to attack Linux which Microsoft saw as a threat to its bottom line. As such SCO was really nothing but a proxy for Microsoft in the dirtiest fight that the IT industry has ever seen.
Oracle is a very successful company that bought the assets of another dying company (SUN) in order to safeguard a line of business and in order to buy the IP rights of that dying company, which included Java.
Note that I'm not defending what Oracle is doing here but the differences between SCO and Oracle are enormous, and are certainly not limited to scale.
In many ways the Oracle case is much more dangerous because it now openly attacks a well established principle (interoperability) and Oracle actually has the resources to do real damage. For now that damage is limited to Oracle shooting in its own foot (Damaging the Java brand in a very clear and concrete way) but that could easily change.
Google has a very long standing habit of doing or buying things that are illegal (youtube, books, caching the web, images) and getting away with them because they have deeper pockets than the copyright owners or because they strike a deal when cornered.
SCO's claims aginst linux ('10's of thousands of lines') were absolutely unfounded, Oracle's claims against Dalvik seem to have at the surface at least some merit.
And Oracle is not simply going to give up on what it perceives to be its right simply because the party they believe is infringing is Google.
Still, I'm rooting for Google to win this one and for Oracle to lose this one, the consequences of the fall-out of an Oracle win would be pretty disastrous.
SCO was a dying company that tried every dirty trick in the book to blackmail the world into giving it a free ride to newfound riches based on ridiculous claims.
Actually, ironically, it's not SCO that tried to sue every Linux vendor, but the Linux company formerly known as Caldera Systems (of Caldera OpenLinux). They purchased SCO's UNIX business and renamed themselves to The SCO Group. The real SCO was renamed to Tarantella.
It's sad, not only is the name of 'old SCO' forever associated with attacks that they did not participate in, the Linux ecosystem was actually under attack by a (former) Linux company.
None of those things you brought up are illegal. Oracle is a scourge and just a step above SCO, but that's a pretty low bar. Making it so you designate something arbitrarily as a "language" and you can be the only princess that implements it is plain evil. Fortunately the appeal is going no where.
There's no way an API should be covered by copyright, for the judge's reasons. If you can get a patent on it, good luck to you; otherwise, it's not proper IP.
Patenting an API would be like patenting a UI -- reasonable under the law. http://www.dbms2.com/2010/03/23/software-innovation-patent/ Whether the law should be changed -- as I think it should be -- to make such patents unreasonable is a separate issue.
I don't see why. There's plenty of creative discretion involved in the writing of an API. I would have expected this to be a fair use issue rather than a copyrightability issue (though IANAL).
"Fair use" is, by definition, an issue involved in copyright. But I see your point- if APIs are copyrightable, then uses of that API may be "fair use." But then someone's got to drag all the potential uses through the courts to determine what's fair use and what's not (because apparently fair use can only be determined by the courts...) I would surmise that, in this dystopian fantasy world (and I hope it remains such), 'interoperability' would be the de facto fair use and any other use of an API would legally require a license. What a nightmare.
Sure, I'm just addressing your fair use comment with my own input.
"...non-interoperable reimplementation of the API"
I do not understand this phrase. If you implement an API that's exactly the same as the API in a library that I publish, the underlying implementation is irrelevant to your clients because your software is now an interoperable replacement for mine. If you implement some API that's not the same as my API (and thus not an interoperable replacement), you can't have infringed on my theoretical API copyright.
Whether or not we limit he discussion to this case, I don't think there's any reason to fear that using an API would be a copyright issue (though again IANAL). The whole purpose of an API is for people to write software against it. I think that people misconstrue what this case is really about and start talking in hyperbolic terms (not that you're doing so, but in the popular press, blogs, etc.).
At the risk of mischaracterizing Oracle's argument, the basic idea is that Google wanted developers to have a familiar API and wanted to reuse some of the tooling built for Java, but there is no way to get a compiled Dalvik program to run on a JVM, and likewise compiled Java software can't be run on Android. So Google piggybacked on the hard work Sun put into designing a coherent (and quite large) API, but didn't really do so in an interoperable way. In some ways the case is reminiscent of the Sun/Microsoft quarrel about Microsoft's extensions to Java (though that also involved trademark issues, as I recall), though many commenters who supported Sun in that case now seem to support Google in this one.
Because it's not an act of creativity to decide that a name or address is needed (for example), and there's very little creativity in deciding to ask for the first name first and the last name second.
Didn't have a big enough stake in it to justify the purchase of Sun. Oracle however, did have a lot riding on Java succeeding and removing the Sun Hardware division as a competitor.
The Sun hardware division wasn't competing with Oracle at the time. I think they bought Sun because they thought it made sense to sell software + hardware and because they didn't want IBM to have Java.
If Larry Ellison hadn't underestimated the cloud trend, the takeover probably wouldn't have happened. Oracle has been very successful with its M&A activities, but this one is clearly a complete desaster.
While Oracle is hard to sympathize with, the actual article never elaborates on it's inflammatory statement as how "developer freedom" is at stake (or what that phrase even means).
I can't tell if this is criticism alone, or if you're also asking the question. It seems these articles and discussions assume that the reader is all-knowing when it comes to the IP issues developers could face in their careers. Allow me to attempt to fill in the gaps.
When you write code, in the U.S. you hold a copyright to it at the moment you put the characters onto disk. In the case of work-for-hire (i.e. you are employed as a software author by your company), the company holds that copyright. No one else has permission to use, copy or distribute the software without the express permission of the copyright owner. Licenses are the mechanism used to bestow rights upon other users (or, in the case of Open Source Software, potentially other developers) of the software.
Switch gears a bit: other companies (vendors) providing interesting systems (those that you or your company are interested in using) also provide information on how to interoperate with their systems and libraries. When using the C family of languages, this information is provided in a machine-readable format known as a "header" - the header file is source code that describes the procedures made available inside the vendor's code libraries. You include this header in your own project so the compiler can validate that you're calling the library code correctly. They've given you a binary library and not the source to the library to help in protecting their rights to their original code.
Now, after years of offering a particular product on the market, a vendor (Vendor A) decides to discontinue offering this particular product regardless of the fact there are numerous client who still use this product and are willing to continue to pay for support. They are not willing, for whatever reasons, to completely overhaul their own systems and incur the immense expense in changing to this vendor's completely new and different product.
Company B steps in offering an interoperable replacement to that old system that's been discontinued by Vendor A. Company B created a completely legal replacement for this system because they did not use Vendor A's source code. They created a "clean room" implementation of the system. As far as the client's systems are concerned, the interfaces into Company B's solution look exactly like Vendor A's system, to the clients network, employees and customers carry on with business as usual.
Courts have ruled that creating systems for such interoperability is legal and necessary. Without such recognition, vendors have the opportunity to lock their customers into the vendor's products. Interoperability is defined by interfaces to systems and libraries. The interface into a library is an Application Programming Interface, or API. The API has pretty much been declared to not be of the expressive type required to obtain copyright protection. If API's become completely protectable by copyright (and thus require a license to use), companies can then limit the ability for others to provide interoperable systems thus limiting competition. In this case, the legal freedom of developers to create tools and apps around an existing system is severely limited and perhaps even eliminated, regardless of the fact that these developers didn't use any code from the vendor in the process.
The legal precedent if the case is reversed on appeal potentially extends beyond just Java; the article is essentially about the ruling that APIs can't be copyrighted, and that numerous amicus curiae briefs argued in favour of APIs being copyrightable.
If APIs can be copyrighted, it would seriously harm interoperability. For example, if the ruling holds, someone could make a payments service which replaces Paypal so seamlessly that to integrate it you can just change the 'paypal.com' string for 'competitorsbrand.com' without redoing all the work you did for Paypal integration. This would be bad for Paypal but would be great for making the market far more efficient. Similarly, if it is reversed on appeal, Wine and Mono could be considered copyright violations and sued by Microsoft.
If it extended to non-software interfaces a reversal could be even worse - imagine if the idea that turning the round wheel in front of the driver causes a car to move in the corresponding direction was a copyrighted interface? In that particular case, Copyright in the US wouldn't have expired until 1985, so other manufacturers would have needed to come up with different interfaces, and switching makes would have been hard.
True. However, Oracle could argue that writing good APIs does require money and domain expertise, which could be considered non-obvious and (maybe) copyrightable. For example, look at the Java date/calendar API; it went through a complete revision and still managed to be broken.
It's a good question, however, if API designs should be copyrightable in the same fashion building blueprints are.
That depends on what you think is important in Java. The language? Plenty of alternatives. The virtual machine? Not so much. Or perhaps even the class library?
I see Oracle as cancer of the corporate world. An old dinosaur who happened to slog into 2013. The new generation of young and socially responsible will hopefully put an end to their kind.
