|
|
| Oracle v. Google - Reexam Update as of 06-27-11 |
 |
|
Tuesday, June 28 2011 @ 09:00 AM EDT
|
Last week we began a tracking table on the various reexaminations filed on the patents that Oracle has asserted against Google in their dispute over JAVA-like code included in the Android operating system. Another office action [PDF] has been issued by the USPTO, this one on the '520 patent, and in this instance Oracle fared a little better. Out of 22 claims subject to reexamination, only eight were rejected.
Updating our table, below,
| Patent No. | Claims | Claims Not Subject to Reexam | Claims Subject to Reexam | Claims Rejected | Claims Surviving |
|---|
| RE38104 | 41 | 10 | 31 | 0 | 41 |
| 5966702 | 23 | 14 | 9 | 9 | 14 |
| 6061520 | 23 | 1 | 22 | 8 | 15 |
| 6125447 | 24 | 0 | 24 | 0 | 24 |
| 6192476 | 21 | 0 | 21 | 17 | 4 |
| 6910205 | 14 | 9 | 5 | 0 | 14 |
| 7426720 | 22 | 2 | 20 | 20 | 2 |
| Totals | 168 | 36 | 132 | 54 | 114 |
We are still awaiting first office actions in three of the cases. In the four cases where an office action has issued the stats are 89 claims, 17 claims not subject to reexam, 72 claims subject to reexam, 54 claims rejected, and 35 claims surviving. Because of the more favorable treatment of the Oracle claims in the most recent office action, the percentage of claims subject to reexamination that have been rejected has now dropped to 75%. If that stat holds for the remaining three patents, Oracle will have about 72 claims out of 168 that survive.
This is a good time to address a question that a number of you have posed with respect to surviving dependent claims, since most of what appears to be claimed in a dependent claim appears to be of limited scope. If a dependent claim survives, you need to read it in its entirety, incorporating the language from the independent claim to which it refers. For example:
You have an independent claim and a dependent claim, as follows (these claims are taken from Oracle's '520 patent):
6. A method in a data processing system, comprising the steps of: receiving code to be run on a processing component to perform an operation;
play executing the code without running the code on the processing component to identify the operation if the code were run by the processing component; and creating an instruction for the processing component to perform the operation.
. . .
8. The method of claim 6 wherein the operation statically initializes an array and wherein the play executing step includes the step of: play executing the code to identify the static initialization of the array.
Claim 6, an independent claim, was rejected in the first office action, but Claim 8, has survived. If the examiner's determination were to stand, how should one read Claim 8? It should be read as follows:
8. A method in a data processing system, comprising the steps of: receiving code to be run on a processing component to perform an operation;
play executing the code without running the code on the processing component to identify the operation if the code were run by the processing component; and creating an instruction for the processing component to perform the operation, wherein the operation statically initializes an array and wherein the play executing step includes the step of: play executing the code to identify the static initialization of the array.
Well, that seems like the patentee has retained Claim 6 despite the fact that Claim 6 was rejected. But, remember, in order to be infringed each and every element of the claim must be found in the allegedly infringing method. By combining Claims 6 and 8 the limitations of Claim 8 are imposed on Claim 6, significantly narrowing the scope of Claim 6 to just those cases that incorporate the limitations of former Claim 8.
This is part of the significant effect of a reexamination. Patent applicants almost always parse the elements of their claimed inventions to claim as broadly as possible in the independent claims, only reflecting the narrowing of those claims in subsequent dependent claims. Frequently, upon reexamination, the examiner will find that the more broadly claimed invention was either not novel or obvious, but that the more limited form (imposing the limitation of the dependent claim on the independent claim) provides a more limited inventive step that is, at least in the eyes of the law and the USPTO, patentable.
So don't expect Oracle (or Interval Licensing or Lodsys) to lose all of the claims that are rejected in a first office action, but watch to see how the independent claims in those patents are narrowed in scope.
|
|
|
|
| Authored by: maroberts on Tuesday, June 28 2011 @ 09:15 AM EDT |
Did Google go for inter- or extra- partes exams?
If so, does Google get to provide more feedback, and does Oracle get to provide
a response to the examiners rejections?[ Reply to This | # ]
|
| |
| Authored by: Anonymous on Tuesday, June 28 2011 @ 09:18 AM EDT |
that the claim is gobbledygook. To the extent it means
anything, it is just general programming concepts that could
in no way be deemed novel. Beyond that, it is simply
meaningless nonsense, precisely the sort of buzzword nonsense
that an incompetent programmer uses to try to make trivial
code sound important to a non-technical person.
It is appalling that patent lawyers and patent examiners can
be tricked in this way. Are you all really so naive? [ Reply to This | # ]
|
| |
| Authored by: feldegast on Tuesday, June 28 2011 @ 09:25 AM EDT |
Off topic comments here please
---
IANAL
My posts are ©2004-2011 and released under the Creative Commons License
Attribution-Noncommercial 2.0
P.J. has permission for commercial use.[ Reply to This | # ]
|
| |
| Authored by: nsomos on Tuesday, June 28 2011 @ 09:32 AM EDT |
Please group any corrections here so they're easy to find.
A summary in the posts title may be helpful.
[ Reply to This | # ]
|
| |
| Authored by: feldegast on Tuesday, June 28 2011 @ 09:33 AM EDT |
Please make links clickable and preview comments before posting to check HTML
---
IANAL
My posts are ©2004-2011 and released under the Creative Commons License
Attribution-Noncommercial 2.0
P.J. has permission for commercial use.[ Reply to This | # ]
|
| |
| Authored by: Anonymous on Tuesday, June 28 2011 @ 09:48 AM EDT |
Isn't what is described in claim 6 done by all compilers, interpreters and
emulators?[ Reply to This | # ]
|
| |
| Authored by: cybervegan on Tuesday, June 28 2011 @ 10:27 AM EDT |
Hi Mark,
Could we maybe have another column on the table that shows how many dependent
claims have been narrowed by the rejection of claims upon which they depend?
We could crowd-source working that out, with your help...
regards,
-cybervegan
---
Software source code is a bit like underwear - you only want to show it off in
public if it's clean and tidy. Refusal could be due to embarrassment or shame...[ Reply to This | # ]
|
| |
| Authored by: Anonymous on Tuesday, June 28 2011 @ 12:36 PM EDT |
The halting problem is not related to this claim. The claim language might
superficially sound similar to the halting problem, but it is not.
The halting problem addreses the most general case, but there are lots of
concrete cases which are easy to solve. For example, usually each instruction of
a virtual machine always terminates.
/Andreas[ Reply to This | # ]
|
| |
| Authored by: JonCB on Tuesday, June 28 2011 @ 08:04 PM EDT |
I've got a suggestion for you Mark. If you're going to keep
using these claim scoreboards (and i think you should,
they're great) could you tweak the columns that you're
displaying a little. The current format doesn't tell me how
many re-exams are still outstanding. This could be
overloaded into the subject to re-exam field (i.e. when we
get a result one way or the other it's no longer "subject to
re-exam") or alternatively a new field.
If you go the new field route then you could lose either the
"not subject to re-exam" field or one of the claims
surviving or rejected fields (i'd imagine the IT geek
intended audience should be able to work out that total
claims - rejected claims = surviving claims).[ Reply to This | # ]
|
| |
| Authored by: Anonymous on Wednesday, June 29 2011 @ 11:04 AM EDT |
While some people looking just at the claim wording characterized it
as similar to a compiler or interpreter, the claim actually refers to something
a bit different. You could think of the action being that of a context-specific
decompiler. Whereas a compiler typically takes some higher-level representation
of a program and produces a different lower-level equivalent representation,
this claim is about recovering a higher-level representation of some actions
that are input as a series of lower-level instructions.
I disagree.
There is no distinction between a compiler and de-compiler other than an
arbitrary assignment of symbolism. A compiler does indeed recover higher-level
representations from lower level representations; for example, when they collect
bits into a character, characters into a token, and tokens into a syntax.
Likewise, a "de-compiler" can be viewed as taking higher lever
representations and converting them to an amalgamation of lower level ones; for
a (processor-specific) example, examine the de-compilation of an x86 string
instruction which produces a "for" loop construct (comprised of "lower level"
individual steps) in what would traditionally be termed a "high level" source
code language.
That is one of the major deficiencies of software
patents, they purport to distinguish particular activities when in reality all
they really do is apply a different symbolism/nomenclature to the same
activity.
[ Reply to This | # ]
|
| |
| Authored by: FreeChief on Wednesday, June 29 2011 @ 12:55 PM EDT |
While some people looking just at the claim wording characterized
it as similar to a compiler or interpreter, the claim actually refers to
something a bit different. You could think of the action being that of a
context-specific decompiler.
First of all, thank you for your
research and legal explanation, much of which goes well outside my area of
competence.
I am one of those who compare the claim to a compiler, so maybe
I should explain.
The claim is not similar to a compiler as a whole, but to
the part of the compiler called the peephole optimizer. I wrote one for a
Pascal compiler as early as the mid 1970s.
Because the compiler looked at
source code and generated object code based upon the source code, it often
generated code from the end of one source command that was redundant with code
generated from the start of the next. So when that first pass was working and
the compiler could compile itself, we added another pass which looked through
the generated code to find sequences which did something in a stupid way and
replaced that sequence with something better.
- scan object code
instruction by instruction
- update internal data structures to reflect what
each instruction does
- if the result can be done more simply, replace the
sequence with a simpler instruction
Given that I can do (did do) that,
what have I learned by reading the claim?
As for the difference between a
compiler and a decompiler — one translates language A to language B, the
other B to A. Does the patent hinge on what we call the
languages?
— Programmer in Chief
[ Reply to This | # ]
|
|
|
|
|
