Initial Thoughts on Oracle vs Google Patent Lawsuit
Today Oracle sued Google over Java patents and copyrights that they claim Google's Android OS infringes. The lawsuit claims that Google knowingly infringed on those patents, and that the continued distribution of Google's Android is harming Oracle's Java Business.
You can read the actual complaint, the patents referenced are:
There is also a copyright lawsuit, but there are not enough details on the complaint to figure out what the claim is. Until there is a trial, we will not really know what is being asked here.
Pundit Prediction Time!
I would like to think that this is going to be solved with a quick settlement where Oracle will shake Google for a few billion dollars and the entire matter will be put behind.
Oracle will likely want to settle with Google under terms that will only cover Google's own use as they want to go shaking other OEM trees for more cash.
An unlikely scenario is for Google to pay the bills for all Android OEMs as they are coming out fast and strong from every corner of the world.
It occurred to me that Oracle could sell all the Java assets to Google. But Google probably passed on this opportunity back when Sun was put on the market.
What Jonathan Schwartz Knew
Sun's Ex-CEO Jonathan Schwartz has recently taken to the blogwaves to blog about the things he could not tell us while he was a CEO of Sun. While he might have found a new voice for gossip from the Sun days, he will not say a word on this matter, because he was likely engaged in shopping the patent lawsuit around.
Sun had created Java, but it turned out to be very difficult for Sun to monetize Java directly after the initial source code license deals that they struck with IBM, Microsoft, Oracle, Netscape and others. They created the J2EE market, just to find that other companies and startups executed better than they did on the systems that they had initially engineered.
Sun was left in the uncomfortable position of being the owner of the technology that everyone was cashing out on, but they themselves had very few revenue streams for Java. Like Clemens Vasters joked on Twitter today:
They had the Microsoft lawsuit cash and they had the embedded licensing business with Java Micro Edition and Java Standard Edition licensing deals.
The open sourcing of Java was also carefully planned. By picking the GPL as their license, they ensured that embedded system OEMs and developers would have to negotiate a different license with Sun if they wanted to use the OpenJDK on their systems.
There is very little public information on the Google/Sun split over Java ME and the creation of Dalvik. The rumors on the grapevine were that Google and Sun could not reach an agreement over the Java Micro Edition licensing. Sun wanted to sit in the middle between Google and the handset OEMs, while Google wanted to create a free-for-all operating system.
When it became clear that they would not be able to reach an agreement, Google started a project to replace Java Micro Edition and they used some clever engineering techniques that blended the best of both worlds.
It is likely that during these negotiations, Google threatened to build their own Java runtime and Sun countered with a list of patents. This would explain why Google went through the trouble of making the Dalvik virtual machine explicitly incompatible with the existing Java virtual machine instructions.
Although Dalvik uses a different set of instructions, Google created a translator that recompiled Java code into Dalvik code, and with this, they worked around whatever licensing technicalities they were aware at the time of the negotiations.
Needless to say, Sun was not happy with Dalvik. Not only because Sun had lost a large licensing deal, but also because it had the potential of becoming the de-facto Java virtual machine that everyone on the embedded space would pick instead of Sun's own Java Micro Edition.
In late 2007 Google announced both Android and the Open Handset Alliance to the public. On the Java front, Sun had delivered on the promise of open sourcing Java, but it had been a rough year for Sun and it would get worse, in the next twelve months after the announcement, Sun stock would lose 80% of its value.
Sun had their plates full, so Sun did not feel the need to react immediately to the Android threat, so they kept their grievances to themselves.
But Jonathan started to shop the company in late 2008. The monetary value of the Java assets had been devaluated due to the open sourcing of the technology under the GPL. I am going to bet that the same careful planning that went into picking the GPL went into pitching the potential for lawsuits.
The world had already witnessed the awesome iPhone and the eyes were on Google to deliver a killer phone. Jonathan must have known this and he must have been pitching this to the potential suitors.
By the time Oracle bought Sun, they knew that they would be going after Google and anyone else with a big, fat checkbook that did not have a licensing deal in place.
And that explains the Exodus of famous Java people from Sun shortly after the acquisition. The wheels of the lawsuit started spinning the moment the sale was done. Those employees are probably under NDA.
Update: I was wrong, apparently Gosling was not under NDA and has confirmed exactly what I said above:
Oracle finally filed a patent lawsuit against Google. Not a big surprise. During the integration meetings between Sun and Oracle where we were being grilled about the patent situation between Sun and Google, we could see the Oracle lawyer's eyes sparkle. Filing patent suits was never in Sun's genetic code. Alas....I hope to avoid getting dragged into the fray: they only picked one of my patents (RE38,104) to sue over.
So now we know that Jonathan shopped Sun with a big "Sue Google" sign. So much for his visionary patent defense against Apple and of course this jewel:
The most egregious of such suits was filed against Sun by Kodak (yes, the film photography people).Egregious, because Kodak had acquired a patent from a defunct computer maker (Wang) for the exclusive purpose of suing Sun over an esoteric technology, Java Remote Method Invocation (“Java RMI” – not exactly the first thing that comes to mind when you hear “Kodak”).
And he was just playing Wang's role a couple of months ago.
Update: this post from the Dalvik announcement era discussed how Dalvik's work around the license-from-Sun challenge.
Some Background on the Java Patents
The Java specification patent grant seems to be only valid as long as you have a fully conformant implementation:
(a) fully implements the Specification including all its required interfaces and functionality;(b) does not modify, subset, superset or otherwise extend the Licensor Name Space, or include any public or protected packages, classes, Java interfaces, fields or methods within the Licensor Name Space other than those required/authorized by the Specification or Specifications being implemented; and
(c) passes the Technology Compatibility Kit (including satisfying the requirements of the applicable TCK Users Guide) for such Specification ("Compliant Implementation").
This is more stringent than the Microsoft Community Promise that applies to .NET as the Community Promise only requires a minimum subset, it does not prevent supersets.
This seems to be what the lawsuit is hinged upon.
Is this it?
I vaguely remember in one of the endless anti-Mono discussions that someone pointed (maybe it was Gosling himself?) that Java had a patent grant for anyone to implement under any conditions.
They pointed to the spec. And I remember seeing this on the spec and thinking that it was a generous patent grant. Perhaps I was confused and the only patent grant is the one in the previous section, but if you know of the other document, please let me know.
Sun's GPL
By GPLing Java, Sun lost some of the exclusive rights that they used to have, in particular, anyone using the open sourced version of the OpenJDK is given the patent rights to run the software.
The problem is that the rights are only available as long as you are using the GPL version of Java. Any patent grants are not available if you use a third-party licensed version of the Java virtual machine. In that case, it seems like the only option would be to to go back to the Sun licensing terms.
Wishful thinking
Too many engineering resources are devoted to Android at Google and at their partner companies, but I can not help to think that Google could migrate Android from Java to the ECMA/ISO CIL and C#.
Unlike the Java patent grant, the Microsoft Community Promise for both C#, the core class libraries and the VM only require that you have a full implementation. Supersetting is allowed.
Additionally, Microsoft has placed the .NET Micro Edition entirely under the Microsoft Public License which comes with an even more generous patent grant, and covers a superset of the code covered by ECMA/ISO 335.
We have open source implementations of both, and even more luckily, the ECMA/ISO VM specification allows for different profiles, to allow for ultra-small or server-sized versions of the VM to be created. Ideal for mobile platforms.
Google could settle current damages with Oracle, and switch to the better designed, more pleasant to use, and more open .NET platform.
Some Humor
There is a silver lining in this whole mess, and it is that the tweetosphere came up with a few funny tweets, here are my favorites:
And while you are here
I am very excited to see the first
MonoTouch book published.
Unix and Linux StackExchange
Help
create
a non-tribal
version of StackOverflow for Unix and Linux questions.
As we know, tribalism makes you stupid. So let us commit to the Linux and Unix Q&A site powered by StackOverflow that will help answer questions for Unix and Linux users of all distributions and blends.
At the time of this writing, only 91 users have committed.
Tell your Solaris, FreeBSD, NetBSD, OpenBSD, Unix, OSX, Linux, Red Hat, Fedora, Ubuntu, Debian, Mandrake, Mint, Arch, Slackware, CentOS, Gentoo, OpenSUSE, friends to commit to it and help create a global community of Unix love.
MonoTools 2 for VisualStudio has been released
We just released Mono Tools for Visual Studio.
There are four main features in MonoTools 2:
- Soft debugger support.
- Faster transfer of your program to the deployment system.
- Support for Visual Studio 2010 in addition to 2008.
- Polish, polish and more polish.
Thanks to everyone that participated on our beta program for all of the bug reports and feedback!
MonoTools is the foundation on which we are building the upcoming Mono for Android toolchain.
New Long-Term Maintenance Mono Release
With the introduction of MonoTools for Visual Studio, we are also moving our long-term maintenance Mono release from the Mono 2.4 release to Mono 2.6, the release that we announced last week.
Getting Started
Download our betas from this page. On Windows, you would install our plugin for either 2008 or 2010 and you need to install Mono 2.6.5 on the target platform (Windows, Linux or MacOS).
On Linux, run `monotools-gui-server' or `monotools-server', this will let Visual Studio connect to your machine. Then proceed from Windows.
On MacOS, double click on the "MonoTools Server" application.
Once you run those, MonoTools will automatically show you the servers on your network that you can deploy to or debug:
ASP.NET debugging with this is a joy!
Soft Debugger
This release is the first one that uses our new soft debugger. With is a more portable engine to debug that will allow our users to debug targets other than Linux/x86 for example OSX and Windows.
This is the engine that we use on MonoTouch and that we are using for Mono on Android.
Our previous debugger, a hard debugger, worked on Linux/x86 systems but was very hard to port to new platforms and to other operating systems. With our new soft debugger we can debug Mono applications running on Windows, helping developers test before moving to Linux.
Faster Transfers
When you are developing large applications or web applications, you want your turn around time from the time that you run hit Run to the site running on Linux to be as short as possible.
Cheap Shot Alert: When dealing with large web sites, we used to behave like J2EE: click run and wait for a month for your app to be loaded into the application server.
This is no longer the case. Deployments that used to take 30 seconds now take 2 seconds.
Support for Visual Studio 2010
Our plugin now supports the Visual Studio 2010 new features for plugin developers.
This means you get a single .vsix package to install, no system installs, no registry messing around, no dedicated installers, none of that.
The full plugin installs in 3 seconds. And you can remove it just as easily.
Then you can just from VS's Mono menu pick "Run In Mono" and pick whether you want to run locally or remotely.
We now also support multiple profiles, so you can debug from Visual Studio your code running on Linux boxes, Mac boxes or your local system.
Polish and more Polish
MonoTools was our first Windows software and we learned a lot about what Windows developers expected.
We polished hundreds of small usability problems that the community reported in our last few iterations. You can also check our release notes for the meaty details.
Appliances
And we integrate directly with SuseStudio to create your ready-to-run appliances directly from Visual Studio.
Mono has migrated to GitHub
We have now migrated all of Mono's source code from the Subversion at our Cambridge office over to GitHub.
We are going to be maintaining a migration FAQ and providing help to developers on irc.gnome.org channel #mono for the new setup.
The web site has not been updated yet and we still reference Subversion urls, but this will be fixed in the next few days.
Mono 2.8 Trick: tracing exceptions
Mono has an strace-like feature built into the runtime. This is useful to see which methods are being called by your application, just invoke Mono with --trace.
Our upcoming version has a neat new feature, when you use --trace=E:ExceptionName or --trace=E:all you get a stack trace of where the exception was thrown from:
$ gmcs.exe mono$ gmcs missing.cs error CS2001: Source file `missing.cs' could not be found Compilation failed: 1 error(s), 0 warnings
And now with tracing enabled, we do it setting the MONO_ENV_OPTIONS variable:
mono$ MONO_ENV_OPTIONS=--trace=E:all gmcs missing.cs[0xb75136f0:] EXCEPTION handling: System.IO.FileNotFoundException: Could not find file "missing.cs".
"{unnamed thread}" tid=0x0xb75136f0 this=0x0x53f18 thread handle 0x403 state : not waiting owns ()
at System.IO.FileStream..ctor (string,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare,int,bool,System.IO.FileOptions) {0x00619}
at System.IO.FileStream..ctor (string,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare) {0x00022}
at (wrapper remoting-invoke-with-check) System.IO.FileStream..ctor (string,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare) {0x0004f}
at System.IO.File.OpenRead (string) {0x0002c}
at Mono.CSharp.Driver.Parse (Mono.CSharp.CompilationUnit) {0x00016}
at Mono.CSharp.Driver.Parse () {0x00068}
at Mono.CSharp.Driver.Compile () {0x00098}
at Mono.CSharp.Driver.Main (string[]) {0x000a2}
at (wrapper runtime-invoke) {Module}.runtime_invoke_int_object (object,intptr,intptr,intptr) {0x00033}
error CS2001: Source file `missing.cs' could not be found
Compilation failed: 1 error(s), 0 warnings
Banshee Ships with Amazon Store Support
Aaron just shipped Banshee 1.7.3 which lets you purchase MP3s from Amazon from the player directly.
Banshee Amazon MP3 Store
Screencast!
Get it fresh!
Building apps for the Retina Display
While adding Retina Display support to TweetStation I learned a couple of tricks that I figured would help other developers.
iOS 4 Points
Apple's Retina Display conveniently doubles the number of pixels on each dimension, the previous iPhone display had 320x480 pixels while the new new phone has 640x960 pixels.
To make existing applications run out of the box on these new displays Apple changed the units on the display and instead of using pixels they now use points. They are not really typographical points, but iOS "points". Both the old iPhones and the new iPhone have a resolution of 320x480 points.
This means that existing code that absolutely positioned views on the screen will get the views laid out in the same positions regardless of the device that the code is running on.
In UIKit points are interpreted based on the value of the UIView.ContentScaleFactor. If the value is 1.0 each point is mapped to one pixel. If the value is set to 2.0 each point is mapped to four pixels (2x on each dimension).
UIKit layout and CoreGraphics rendering primitives will automatically take this factor into account and position and render accordingly.
Images
The Image loading routines have been extended to load higher-resolution images by default when you use UIImage.FromBundle. On Retina Displays the code will probe for a file@2x.ext filename when you request file.ext to be loaded. For example this loads the background texture you use:
texture = UIImage.FromBundle ("Images/texture.png");
TweetStation's images are here.
Bitmaps and Inkscape
All the icons and images on TweetStation were done using Inkscape. When I exported the icons they would invariably look blurry. For example, this is from my first attempt at getting the swipe menu on TweetStation working:
I would just draw my icons on Inkscape and then export them as bitmaps. Inkscape would then anti-alias the result, you can see how the reply icon is not rendered properly:
The Inkscape FAQ contains this bit of information that is very useful if you are drawing small icons:
With the current renderer, it is not possible to completely get rid of antialiasing. However, it is possible to partially suppress it on export. Usually, antialiasing is unwelcome in horizontal and vertical lines which become "blurred". To work around this, make sure your horizontal/vertical edges are snapped on the pixel grid, and all strokes are a whole number of pixels wide. Then, export bitmap at the default 90dpi so that 1 px unit corresponds to 1 bitmap pixel. In the resulting bitmap, snapped color boundaries will be perfectly crisp.
These are the settings that I use now to export the same graphic:
I used guidelines on Inkscape to help me:
This is the new version of the icon before it gets composited with the background
To export the same image at high resolution, set the DPI in the dialog box to 180. Inkscape will automatically change the width and height for you.
The other problem that I had was related to my centering code, this is what the rewteet icon looks like from the menu above:
The blurry sides of the retweet icon were caused by the math code setting the X position of the image at a fraction of a point (0.5).
After fixing both problems and adding a nice backdrop shadow, this is what the menu looks like:
Graphics Context
Loading images with more pixels for the background texture and the icons wont do you any good if you are drawing the images yourself.
When you create a graphics context using the pre-iOS 4 APIs you will end up with a context that assumes that you are not aware of the Retina Display and hence will rescale your drawing up. When you create an image context of 100x100 points like this:
UIGraphics.BeginImageContext (new SizeF (100, 100));
You will end up with a context that has 200x200 points, but will automatically double all of your pen widths and will scale any images up. If you had a high-resolution image, it will first be scaled down when rendering to the context, then scaled up when rendering the data.
To take advantage of the retina display you need to call a new method:
UIGraphics.BeginImageContextWithOptions (SizeF size, bool opaque, float scale);
If you set scale to zero, it will pick 1.0 for old display and 2.0 for retina displays. I use this helper method to support both iOS 3.x and iOS 4.0:
void BeginImageContext (SizeF size)
{
if (Graphics.HighRes)
UIGraphics.BeginImageContextWithOptions (size, false, 0);
else
UIGraphics.BeginImageContext (size);
}
This is how the swipe menu is rendered at high resolution:
More
Apple's Supporting Resolution Independence document has more information.
Mono's Git Migration
Mono's source code is being migrated to GitHub on July 22nd, starting at 9am Boston time.
We are psyched that Github was kind enough to host Mono's large repositories for free on their system. We are also taking advantage of their new Organizations functionality.
Gonzalo posted the following details about the migration:
We are moving our source code repository to GitHub. On July 22nd ~9am EDT (1300 GMT) the subversion repository at "svn +ssh://mono-cvs.ximian.com/source" will be set to read-only mode and kept that way forever. We estimate that the process of migrating all the projects and moving them to GitHub will take more than 3 and less than 8 hours. Once it is completed we will send an email to this list with URLs to the new repositories, FAQs,...
If you have any questions about the migration, please ask them here and we will add them to our Git Migration FAQ.
Fresh Mono Baked
Andrew just announced Mono 2.6.7, the version that is replacing our long-term maintenance release of Mono with plenty of bug fixes as well as the following new features:
- Microsoft's ASP.NET MVC2 is now bundled with Mono.
- Upgraded xbuild tool (Mono's msbuild)
- Upgraded our LINQ to SQL (DbLinq)
- Upgraded our Soft Debugger
- We now publish CentOS/RHEL packages.
Our CentOS/RHEL packages install on /opt/novell/mono, just like our packages for SUSE Linux Enterprise and should not conflict with your own packages of Mono that you might have from some other sources.
Microsoft Licensing Changes for IronRuby and IronPython
If you check the latest versions of IronRubyIronPython or the Dynamic Language Runtime you will see that Microsoft has now relicensed the code from the Microsoft Permissive License to the Apache 2 License.
Spaniard Anger Towards Mexicans
It has been brought to my attention that the upcoming 200 year celebration of Mexico's independence from Spain on September 15th has lead to office unrest all across the country between teams that have both Mexicans and Spaniards working side-by-side.
Spain might have won the world cup, but Mexico upgraded from being a colony of Spain and being subject to the will of the Kings of Spain, to a democracy subject to the will of drug dealers.
To resolve this animosity, I propose we settle the score this September 15th with a cook-off between Spaniard food and Mexican food.
I propose the cook-off from the Novell/Cambridge team be held at my place the weekend before the festivities to settle the score before the celebrations take place. We will make delicious tacos. Gonzalo will be making a Paella.
New Mono Runtime Features
With Mono 2.8 we want to make it very easy for developers to use the LLVM powered Mono engine and the new Mono Garbage Collector.
Previously users had to build Mono from source code and choose as part of their build whether they wanted the Mono VM to be powered by LLVM or not and whether they wanted to use the Boehm GC or the new Generational GC. Typically users would have to keep multiple parallel Mono installations.
This is no longer necessary.
Mono 2.8 by default behaves just like any other Mono, by default you get the regular fast Mono JIT with the Boehm GC.
You can then pass the --llvm flag to instruct the Mono runtime to use LLVM for code generation (much slower to JIT, but produces better code for long-running applications or compute intensive applications).
To use the new garbage collector you pass the --gc=sgen command line argument.
New MONO_ENV_OPTIONS
We wanted users to try LLVM, SGen or the LLVM/Sgen combination without having to modify all of their launch scripts or existing tools so we introduced a new environment variable that Mono parses on startup, the MONO_ENV_OPTIONS variable.
Mono will parse the contents of the MONO_ENV_OPTIONS variable as if the arguments had been passed in the command line, so you could do a full bootstrap of Mono's class libraries with both by doing:
$ export MONO_ENV_OPTIONS="--llvm --gc=sgen" $ make
How to test LLVM and SGen
Update: Both the --gc=sgen and --llvm options depend on your architecture and operating system being supported by SGen and LLVM and depend on you compiling your runtime with these features.
SGen will be automatically enabled if your OS/architecture is supported when you run configure.
LLVM requires the installation of the LLVM libraries. We strongly recommend that you use our modified version of LLVM that has been extended to support various constructs required by .NET.
For more information on compiling LLVM and building your Mono with it, see our web page
GZip your downloads
Gonzalo yesterday pointed me to a feature in the HTTP client stack for .NET that I did not know about.
If you want the server to gzip the response before sending it to you, set the AutomaticDecompression flag in your HttpWebRequest:
var request = (HttpWebRequest) WebRequest.Create (uri); request.AutomaticDecompression = DecompressionMethods.GZip;
This will set the Accept-Encoding HTTP header to gzip when you make your connection and automatically decompress this for you when you get the response stream.
Update: on the comments there is a suggestion that Deflate is another option you can use, and you can combine both GZip + Deflate on the flags above.
Update2: Dennis Dietric emailed me to point out an important bit: if the server side does not support GZip or Deflate content, you will could get a 406 return code, so when dealing with third party web sites you need to be prepared to fall back and retry your request without compression in place. The relevant sections of rfc 2616 are 10.4.7, 14.1 and 14.3.
Microsoft MS-PL code in Mono
Over the past couple of years Microsoft has been open sourcing some key .NET libraries under the MS-PL or Apache 2 license.
We are tremendously grateful to Microsoft for making these components open source. This has allowed us to distribute this in the past, and we are going to be bundling a lot more of it with Mono 2.8:
In Mono 2.8, the following assemblies and code come from Microsoft:
- Managed Extensibility Framework, a framework to create extensible applications (blogged about their open sourcing).
- The Dynamic Language Runtime is the engine that powers IronPython and IronRuby, but also third party efforts like IronJS and RemObject's Javascript compiler. This lives largely in the System.Core assembly in .NET 4. Some of the code is also used in Mono's version of System.Numerics.
- OData's .NET client (System.Data.Services.Client), I blogged about this here.
- ASP.NET MVC both MVC1 and MVC2.
- Microsoft's AJAX library for use with ASP.NET WebForms.
- Silverlight's Controls, these are used by Moonlight.
With Mono 2.8 we are going to default to the .NET 4.0 profile. So from the list above MEF, the DLR, OData and MVC2 become first class citizens in Mono-land, no longer third-party packages that you needed to install.
Update: as of July 17th 2010, the DLR, IronPython and IronRuby changed their licenses from MS-PL to Apache2.
First MonoTouch Book is out
I am very excited to see the first
MonoTouch book published.
You could not ask for a better team of authors to explain the MonoTouch and the iPhone platform. Chris, Craig, Martin, Rory, and Wally.
This book was a team effort by various active members of the MonoTouch community. They nurtured the community from the start by exploring MonoTouch, by reporting bugs and missing functionality in MonoTouch and by guiding .NET developers through the new world of building iPhone applications.
Congratulations on the book release guys!
You can find them here: