Circumventing Patent 5,764,992

The problematic claims are 1, 12, 17, and 27. These are the independent claims and if one does not infringe them then one does not infringe on the others, which are more restrictive. The other (dependent) claims basically cover variations in how the new version of a widget replaces the old one (copying, moving, renaming, deleting, etc.) and the moment at which that happens (startup, shut down, in the background, etc.).

Claim 1

This describes a method in which the current version of a program is seen to automatically update itself after having determined that a remote updated version exists independently of functions performed by any resource external to the current version.

Our understanding is that, in order to hold, this claim requires the conjunction of three aspects:

• Autonomy. The program must update itself, if a third-party program (for instance, a widget user agent) is performing the update, the claim does not hold.
• Automaticity. The process has to be started automatically, rather than be user-initiated.
• Independence. The process is described as not involving "any resource external" to the program; we wonder if that might include referring to a server or update file separate from the updated program. This needs further analysis by the PAG.

Claim 12

This is a different beast altogether. It includes provisions for using an external resource to determine that an update is needed, and includes the possibility of a "logic module" (e.g. a library or API) being used to update a program that isn't itself.

However, said "logic module" must be "incorporated" or otherwise referenced by "at least some" of the programs that may be updated. Our reading is that if widgets themselves have no means to even request being updated (e.g. by calling an update() method on an object provided to them by the user agent) then the user agent does not infringe. Of course, it is always possible that a widget would implement its own way of updating itself (independently of the user agent) but in that case it is the widget itself that is infringing on the patent (as it can indeed infringe on many other patents), but not the implementation.

Claim 17

This describes the case of a program updating itself over the network through various schemes of local renaming of the executable. But it is clear that it must be the program itself that is doing the updating, not a third party.

Claim 27

Again, in this claim "the current version of the software application program comprises" means to locate an update for itself and perform it. No discussion is made of third party processing.

Conclusion on Technical Analysis

Our technical evaluation is that the patent is only infringed in the case in which the widget updates itself, either by checking directly for a new version or by calling an API that does it. The "Widgets: Updates" specification is not currently precise enough to make a fair assessment of whether it infringes, but it does have an informative section that indicates that such a process could be possible.

On the issue of autonomy: in order to escape infringement any reference to a process to through which an individual widget may update itself, or request that it be updated, could be removed. It appears that the patent is not infringed if the user agent (e.g. the "Web Runtime" environment or another part of the system) performs the update of its own accord.

Furthermore, on the issue of automaticity, if the user agent then notifies and invites the user to update by actively "pulling" the updated version of the program to the computing device, this would also appear to be outside the scope of the Apple patent.

The Widgets Updates Patent Advisory Group is chartered to study issues and propose solutions related to a patent disclosure from Apple, Inc., concerning the Widgets 1.0: Updates Working Draft.

PAG -Chair is Rigo Wenning (W3C). The W3C Staff Contacts for the Widgets Updates PAG are Doug Schepers and Michael(tm) Smith.