Microsoft vs Salesforce vs the World

What do you know?

Microsoft seems to be scared of Salesforce and is going after them
with a battery of patents

Perhaps the most interesting thing about this lawsuit is that Microsoft is using one of the patents that they acquired from Silicon Graphics. Microsoft bought SGI patents in three batches, the first batch in 1995, the second in 2001 and the third as part of Silicon Graphics attempt to stay in business a year before they were bought by Rackable.

The lawsuit against Salesforce includes the Ajax patent for menus on the client side. Ironic because Microsoft is the inventor of the technology that became known as Ajax, and yet, they resorted to an older patent that covers some areas of client-side scripting on the browser.

Some of these patents are from the mid-90s, remember that the patent
system changed on June 6th of 1995. Patents filed before this date
could be milked for seventeen years, patents filed after this date can be milked for twenty years.

Here are the patents:

7,251,653: The Pivot Table and "views" patent.

5,742,768: This is the Silicon Graphics "Ajax" patent. Potentially Microsoft can go after anyone that has any sort of dynamic content on a web page, or at least those that offer a list of options without going back to the server for more information.

The challenge with this patent will be to find HTML-based
client-side menus before July 16th of 1996.

5,644,737: This is a nasty one as it covers the stackable toolbars, we have all grown used to having stackable toolbars (and curiously, Microsoft Office just moved away from stackable toolbars to a large static toolbar).

Even if this is used against Salesforce, this is a problem for desktop applications: Openoffice, Kde and Gnome in the Linux world are affected, and pretty much every desktop application on Windows.

The challenge date: June 6th of 1995.

6.263,352: It should not be hard to find evidence that CGI scripts were using either bourne shell interpolation or Perl interpolation to create the stylesheets that this patent is making a reference to.

The patent was filed in November 27th of 1995, and the WWW-Talk mailing list had discussions about the CGI interface going back to 1993. We need to find any sort of Perl script from 1995 that would show the use of templates for generating HTML output.

Something tells me that Salesforce is hiring software veterans to track these down now.

5,845,077: Distribution of Software Updates. This one is so broad that it goes beyond Salesforce's own problems. This patent was filed in November of 1995 and affects anyone doing network-based software updates.

In the Linux world, this affects every Linux distribution that ever had an updating software system or software installation catalog. But it also affects and Windows programs that phone home to get patches, updates or new functionality.

6,122,558: From the bouquet of patents this deserves some award for being impossible for Microsoft to prove and for falling in the "who gives a fuck" category.

The patent discusses using schemas in control panels.

6,542,164 and 6,281,879: Microsoft patents the timeout on tooltips, a possible workaround this patent is to not compute acceleration as the invention only relates to acceleration being taken into account while the cursor is moving. It could be argued that no motion means also zero acceleration.

This patent is not patenting functionality itself, but usability. A disgusting trend, because it is not really adding functionality or seems like a big invention. This is a patent that was granted for ergonomics.

The patent date: June 12 of 2001.

5,941,947: Nasty patent that covers Access Control Lists over the network. This means anyone that implements a distributed login/password system is probably infringing.

The patent date: August 18th, 1995. This is helpful because there were various distributed login/password systems that predate the patent (Sun's NIS) and will weaken many of the claims.

Sun, Oracle, Java and Microsoft patents.

Ever since Oracle announced its intentions of getting its hands on Sun there has been various lingering questions. What happens to the Microsoft-Sun cross patent license agreement that was put in place a few years ago?

When Microsoft and Sun signed that agreement, the companies agreed to share their patent portfolio and they gave each other pats in the back.

What has never been clear is what happened to Microsoft's patents on .NET when Sun open sourced Java under the GPL? Has Sun actually transferred Microsoft's patents on .NET to the public by releasing it under the GPL?

This is the timeline:

Microsoft and Sun Sign 10 year Patent License Agreement: They say nice things in the press and promise to use each other patents.

Sun extends Java with Microsoft patents: C# has a feature called Extensible Metadata, the guys at Sun copied this idea, renamed it and put it in Java. There are likely more, but I am too lazy to look them up.

Sun open sources Java under the GPL Although the GPL requires that people redistributing code transfer the patents they have, this does not apply to Sun which probably did not have the rights to do so. Sun is not going to sue itself, so there would be no reason for distributing software with half the patents they had.

Oracle Buys Sun: and as far as we know, there is no Oracle/Microsoft agreement. The Sun/Microsoft agreement will remain in place, the Sun group would get access to Microsoft technologies and patents, and Microsoft only gets access to Sun patents, not Oracle.

The Question Remains Did Microsoft accidentally let go of all of their .NET patents?

Language Envy

Microsoft envy does not end with the Mono folks which made their C# and VB knockoffs for Linux. Language envy is alive and kicking everywhere in the Linux world. Today we look at some open source technologies and languages that have copy-pasted some Microsoft covered patents and are putting everyone in danger.

Let us begin our journey into the patent infested waters with the Vala Language. Vala is a language inspired with C#, so inspired that they compare themselves directly with C#. They also compared themselves with Java, and when they do, the text reads like a C# vs Java document more than anything else.

The Mono flamewars did not prevent these geniuses from doing a carbon copy of a Microsoft technology. They figured that copying some features while making some slight changes to the syntax and distancing themselves from Microsoft would do the trick.

A quick look through the patent system reveals Vala is infringing happily left and right on Microsoft property. Let us see what our Google-fu renders:

6951022, March 2001 and Development system with methods for type-safe delegation of object events to event handlers of other objects from January 1996 describes the invention:

A visual development system is described which provide "method pointers" allowing a developer/user to achieve delegation between objects programmatically as well as visually. Delegation "binds" an event source with an event handler. This binding is directly supported within the programming of the system.

The Vala Tutorial:

Delegates represent methods, allowing chunks of code to be passed around like objects.

The A development system providing a property-method-event programming (PME) model for developing context-free reusable software components patent expands on the delegate idea and describes events and properties, a useful feature in C#.

If you are wondering where you have seen these before, look no further than the Vala tutorial:

It is good object oriented programming practice to hide implementation details from the users of your classes (information hiding principle), so you can later change the internals without breaking the public API. One practice is to make fields private and provide accessor methods for getting and setting their values (getters and setters).

This syntax should be familiar to C# programmers. A property has a get and a set block for getting and setting its value. value is a keyword that represents the new value that should be assigned to the property.

Now you can access the property as if it was a public field. But behind the scenes the code in the get and set blocks is executed.

Due to Microsoft's patent promise, it seemed natural to dismiss any further investigation on patent infringements on anything derived from C# and .NET.

But bloggers quickly analyzed Microsoft's patent promise and they found a series of loopholes on it.

The promise covers a subset of Mono, but the patent promise is limited to _conforming_ implementations of the standards. This means that _some_ Mono parts are covered, but it _also_ means that the promise does not apply to any other technologies that might copy ideas selectively.

This means that neither Java, nor Vala get a free ride.

The weasel wording is:

Microsoft irrevocably promises not to assert any Microsoft Necessary Claims against you for making, using, selling, offering for sale, importing or distributing any implementation, to the extent it conforms to one of the Covered Specifications, and is compliant with all of the required parts of the mandatory provisions of that specification ("Covered Implementation"), subject to the following:

You read that right. Either you implement the whole spec or Microsoft has every right to sue. It is an ironic turn of events: Mono and C# are safer from patent litigation than Vala is.

At some point C# introduced "nullable types", a feature covered by patent 7647580, Vala carbon copied the feature and exposed everyone to a tasty lawsuit, the question is, can prior out be found?

They copied C#'s feature and syntax verbatim:

An instance of a nullable type T? can either be a value of type T or null.

nullable-type:
value-type ?
reference-type ?

The problems go deeper, another quick Google finds that the namespace system used in C# is also patented, and it is a system that Vala copies verbatim.

Microsoft also patented the C# style of type inferencing, another system that Vala copied verbatim.

They also copied Microsoft patented Lambda Expressions. Down to the syntax described on the patent:

Declaring a method inline must be done with relation to a delegate or signal, so that the method signature is already defined. Parameter and return types are then learned from the signature. A lambda definition is an expression that returns an instance of a particular delegate type, and so can be assigned to a variable declared for the same type. Each time that the lambda expression is evaluated it will return a reference to exactly the same method, though this is never an issue as methods are immutable in Vala.


lambda-declaration:
( [ lambda-params-list ] ) => { statement-list }

lambda-params-list:
identifier [ , lambda-params-list ]
It is important to realise that Vala's lambda methods are not closures as in some other languages. They cannot access the local variables that existed in the scope they were created in. They may however directly access the object they were created by, using the "this" reference, if that is appropriate in the context.

These are only the results of a quick Google search for "C# language" and Microsoft on Google.com/Patents.

But Vala is not alone here, Python and Java also copied ideas from C#, we will look at some of those in a future post.