decoration decoration
Stories

GROKLAW
When you want to know more...
decoration
For layout only
Home
Archives
Site Map
Search
About Groklaw
Awards
Legal Research
Timelines
ApplevSamsung
ApplevSamsung p.2
ArchiveExplorer
Autozone
Bilski
Cases
Cast: Lawyers
Comes v. MS
Contracts/Documents
Courts
DRM
Gordon v MS
GPL
Grokdoc
HTML How To
IPI v RH
IV v. Google
Legal Docs
Lodsys
MS Litigations
MSvB&N
News Picks
Novell v. MS
Novell-MS Deal
ODF/OOXML
OOXML Appeals
OraclevGoogle
Patents
ProjectMonterey
Psystar
Quote Database
Red Hat v SCO
Salus Book
SCEA v Hotz
SCO Appeals
SCO Bankruptcy
SCO Financials
SCO Overview
SCO v IBM
SCO v Novell
SCO:Soup2Nuts
SCOsource
Sean Daly
Software Patents
Switch to Linux
Transcripts
Unix Books
Your contributions keep Groklaw going.
To donate to Groklaw 2.0:

Groklaw Gear

Click here to send an email to the editor of this weblog.


Contact PJ

Click here to email PJ. You won't find me on Facebook Donate Paypal


User Functions

Username:

Password:

Don't have an account yet? Sign up as a New User

No Legal Advice

The information on Groklaw is not intended to constitute legal advice. While Mark is a lawyer and he has asked other lawyers and law students to contribute articles, all of these articles are offered to help educate, not to provide specific legal advice. They are not your lawyers.

Here's Groklaw's comments policy.


What's New

STORIES
No new stories

COMMENTS last 48 hrs
No new comments


Sponsors

Hosting:
hosted by ibiblio

On servers donated to ibiblio by AMD.

Webmaster
Day 5 in Patent Phase at Oracle v. Google Trial ~pj - McFadden, Parr, August - Updated 3Xs
Friday, May 11 2012 @ 06:09 PM EDT

Today's reporter for Groklaw at the Oracle v. Google trial has filed his reports, three of them so far, and they are voluminous. You will enjoy his thorough account of the day's events.

I saw the tweeting journalists saying, Oh no, more code. But that's exactly what you want. The journalists zone out, but what I see in the notes is that the judge is paying very, very close attention, enough to ask meaningful questions. So, enjoy. I'll keep adding to the reports, but I have the first one done. [They're all done now.] Witnesses today were Andrew McFadden, Terence Parr, and David August, all Google's witnesses, providing expert testimony that Google didn't use Oracle's patented technology.

One bad news bit for Google: the judge has granted Oracle's motion for judgment as a matter of law on the directly copied test files, in question 3b of the jury's instructions, that they had decided Google didn't infringe, overruling their opposite finding. And here's the order [PDF]. The judge seems to be going to great lengths to ensure any appeal will not require a new trial.

Jump To Comments

[Update 1, Update 2, Update 3]

The Order reads like this:
The evidence at trial showed that Google decompiled eight Java files and copied them each in their entirety. No reasonable jury could find that the copying of entire computer files was de minimis. The trial record contains the source code for the Java code files (TX 623.2–623.8), decompiled versions of Java code files (TX 896.1–896.8), and corresponding Android code files (TX 1031–40). Professor John Mitchell testified about the decompilation process, how he determined that the eight files were decompiled and how, in a side-by-side comparison he found “that the actual code matches completely” (Tr. at 1259–1260).

In its opposition brief, Google argues that the jury may have found that Google’s use of the copied files was de minimis because these copied files were only “test files” that were not shipped on Android phones. This is unpersuasive. Professor Mitchell testified that using the copied files even as test files would have been significant use. There was no testimony to the contrary. Moreover, our court of appeals has held that it is the amount of copying as compared to plaintiff’s work that matters for the de minimis inquiry, not how the accused infringer used the copied work. Newton v. Diamond, 388 F.3d 1189, 1195 (9th Cir. 2004). Here, Google has admitted to copying the entire files. No reasonable jury could find that this copying was de minimis.

For the reasons stated, Oracle’s motion for judgment as a matter of law of infringement of the decompiled files is GRANTED. The answer to Question 3B on the Special Verdict Form from phase one will be deemed “Yes.”

I don't think this alters the math extraordinarily, although it could, in that test files don't normally ship, and users certainly don't use them. But it does add one more item for a Google appeal. I think one could copy entire files and in the bigger picture still find it was de minimis, and in the case of files that aren't used after the test, maybe the jury viewed it that way. I certainly do. But it's one more item for David Boies to try to persuade the jury in the damages phase are worth beeellions. Oracle has opted to go for actual damages, not statutory, despite the judge's warning that they are making a mistake, and despite Oracle earlier stating it would rely on statutory damages, so there will be a phase three.

Here's how the discussion went, according to our reporter's notes:

Judge: I'm granting Rule 50 for Oracle on the seven decompiled files. The instructions I gave have only one possible answer: yes. That's the only part that will be granted. That being said, you don't have the damage study that ties to that infringement. [The judge explains that even though Oracle doesn't have any hope of showing non-trivial damages, he's going to do everything by the book and give them their chance in front of the jury, just to guarantee they have nothing to complain about on appeal. Oracle interjects periodically to complain, but the judge cuts him off every time. I wish I'd managed to transcribe his whole rant.] Judge: The way this should work is we'll start the trial, you put in whatever you have you put in your expert reports, and you can't change them. Yours don't even come close to what you're asking for. It would be the height of ridiculousness to say that those nine lines, you get hundreds of millions of dollars.

We'll keep the jury here, you can put on your damages case, such as it is. I'll explain to the jury that you've got no evidence.

You've got to tie it in to the actual things they found infringement on, which is nine lines of code. If you can prove real damages on that, you're a great lawyer. [Smiles at Boies and Jacobs - both standing side by side, so unclear which he means]…

Oracle: We don't believe it's possible to tie specific damages to rangeCheck or to these files. The only issue is whether we're entitled to make an infringer's profits case. We're saying once you have proved infringement, we think we have a claim for infringer's profits, and the burden of proof is on them. The question is not how much we're entitled to, it's who has the burden.

We're not going to have proof of damages, because we're not claiming damages. It's going to be infringer's profits.

If given the relative contribution of these items to Android, there's an inability for us to seek infringer's profits, then there's no need for a trial. But if the court sees our case--

Judge: I said, you can make your pitch to the jury. This is being sprung on me... if you want to say to the jury that you're asking for hundreds of millions of dollars for nine lines of code, you can do that if you want. I'm not going to blurt out some ruling now. I took back what I said yesterday: if you want to make out a case for infringer's profits based on nine lines of code and seven files that aren't even part of the Android system, well, that's an extremely weak proposition, but I can't tell you it's illegal as a matter of law. It could be I'd be surprised by some statement in a decision somewhere.

Google said he didn't think that would happen, meaning that they don't agree that there is any such decision.

Update 1: Here's an article [PDF] that will give you an overview of what infringers' profits means, "Accounting for Profits in a Copyright Infringement Action: A Restitutionary Perspective," and I think you'll see how malevolent it can be. The article takes a reasonable tone, but I doubt Oracle will. What I don't understand until I research it is the statute says you get actual damages AND infringers' profits, if not covered by the actual. Does that really mean you get infringers' profits if there are no actual damages? That seems to be the theory being advanced. And according to this article, "Proving Disgorgement Damages in a Copyright Infringement Case Is a Three-act Play" in the Florida Bar Journal, it looks at first glance like it is at least arguable, in that infringers' profits are to cover things that can't be proven to be actual damages tied to the infringement:

As aptly stated in Harper & Row, Publishers, Inc. v. Nation Enterprises, 471 U.S. 539, 567 (1985), “[R]arely will a case of copyright infringement present such clear-cut evidence of actual damage.” Because actual damages are often difficult to quantify with reasonable precision, infringement cases usually focus upon the other portion of this damage option, commonly referred to as disgorgement of the infringer’s profits. Remembering that the Copyright Act allows the plaintiff to disgorge the defendant’s profits, only those profits that are “not taken into account in computing actual damages” will be considered. Where a plaintiff opts to seek both actual damages and disgorgement, typically the plaintiff recovers “the larger of the two amounts or all of one and so much of the other as is not included in the one.” Courts are required to scrutinize the damage model to ensure that no double recovery occurs. Where it is assumed that the infringer’s profits resulted from sales that were diverted from the plaintiff’s authorized goods, a court cannot assess both actual damages and disgorgement damages for such calculations would yield a double recovery. However, where the infringer is selling in a different market than the copyright owner or where the infringer’s sales are not a result of a diversion of customers or sales from the copyright owner, then it is appropriate to assess both actual damages, as well as disgorgement damages.
I left out the footnotes, so read the original if you want the fine print. The idea is that aside from making the victim whole, there is the idea that a willful infringer shouldn't be allowed to profit from what he did, even if it can't be demonstrated that there is a tie to the infringement. In other words, the sky's the limit. And that's appealing if what you want is either money and/or to pressure the other side to do what you want. - End Update.]

It's the usual smoke and mirrors. They can't prove damages, because there can't be any from such as this, and Android has been a money loser anyhow, according to what we've seen in the litigation, until very recently, but they want to use some wording in the law to try for money on a technicality, in essence. This is at this point a penny ante case. But they want big bucks.

It's a Boies Schiller clown show, and that's what the judge in effect told them. Like gambling for money. And it means the appeals will go on and on forever and a day, I think. It's also a make-work chore for Google. Maybe Oracle would like them to settle.

Remember the mountain of code that SCO claimed to have? Extrapolate. The paralegal "finding" Amendment 2 that would supposedly "prove" SCO owned the copyrights? The executives who lined up and streamed into the courtroom to swear on the Bible that the copyrights were supposed to transfer to SCO? The "but-for" world? All smoke and mirrors. None of it was so, but you never know what a jury, or a judge, might believe, but in the end SCO lost. We've seen Boies Schiller before, so there is no surprise that they'd fight like demons over trivia that in the end won't make any difference. But I am, I confess, deeply saddened and surprised that Morrison & Foerster isn't too embarrassed to be associated with something like this in a fact pattern like this. I had thought better of that firm.

On today's patent testimony, the whole point of all the questions is to try to show that Google's Android doesn't in any way use Oracle's patented technology. Oracle, of course, wishes to prove the opposite. So that is what all the detailed questions are for. If you read Update 3 to our Tuesday coverage, the Google opening statement, you'll understand today's questions and answers a lot better.

Update 2: Also, you might find it helpful, if you want to understand the patents in suit to read iProgrammer's explanation. It will help you to understand what the patents cover, and probably it will also help you to grasp why every technically clueful person reads these two patents and rolls his or her eyes in frustration at the USPTO for even allowing such obvious things to be patented at all. Keep in mind though that due to reexaminations, only two of the '520's claims remain: 1 and 20. Claim 20 is a dependent claim and it incorporates independent claim 18. Here's the '520 patent. Here's the '104 patent [PDF]. The claims remaining are 11, 27, 29, 39, 40, and 41. And you'll understand Google's arguments that it doesn't use the patented methods. Invalidity is not at issue at this stage. I suppose if some rocking new evidence of prior art showed up, it could be at the USPTO. After looking at precisely what each does, he concludes:

At the end of the day, I have to say that neither idea seems novel and any good programmer considering the problem of improving Java's static array initialization or how to make an interpreted language run faster would propose both methods described - without thinking that the ideas were novel or patentable.

As I said earlier, if this is the standard required to obtain a software patent we should all file at least two or three for every program we write.

Excuse me I've just notice that I exchanged some memory for speed in a program by a trick that probably only nine out of ten programmers would spot immediately so I need to fill in a patent application....

Software patents appear to be nonsense.

The author notes that the '104 patent is a James Gosling patent, so he tries hard to see why it's worthy of a patent, given the author. But here's the likeliest explanation from Mr. Gosling himself, from a Register article last year, "Java daddy says Sun engineers ran 'goofiest patent' contest":
Sun engineers once ran an unofficial competition to see who could get the "goofiest" invention past the US patent office, according to former Sun man and Java founder James Gosling....

Gosling says Sun didn't pay patents much heed until the company was successfully sued by IBM for infringing on its so-called RISC patent. Then Sun went on a "patent binge", and yes, this included some less-than-serious filings.

"Even though we had a basic distaste for patents, the game is what it is, and patents are essential in modern corporations, if only as a defensive measure," he writes. "There was even an unofficial competition to see who could get the goofiest patent through the system."... No, Gosling doesn't claim that the seven patents waved by Oracle were part of Sun's "goofy" contest. But he played both sides of the fence — the goofy and the ostensibly serious — and you have to wonder if the same goes for others named in those seven patents. You might even wonder if there is a fence. In filing their goofy patents, Gosling and his colleagues were attempting to expose the goofiness of patents filed in all seriousness.

The article was written back when Oracle had seven patents in suit. There are now only two. As you can see, the problem with goofy patent contests is that years later, someone like Oracle comes along and uses them as serious weapons. That's the tragedy of the USPTO, that they seem to have no engineers who are able to spot a goofy patent application when they see one. - End Update 2.]

Here's part one of our reporter's reports:

Fri May 11 07:31:44 PDT 2012

Before the Jury Enters:

Everyone seems to be here except the judge. I'm surprised to see so many media people here -- I count eight, not including myself.

The judge walks in, and lawyers start talking to him immediately.

Oracle: We've been working through counts of interfaces, classes, etc. trying to reach an agreement.

Judge: When will it happen?

Oracle: We sent a tally late last night.

Judge: Sure, but how long will it take until you agree? It might be several weeks. [laughter]

Oracle: Okay, we have three things. First, Oracle is not electing statutory damages on the copyright claims.

[...]

Judge: I'm granting Rule 50 for Oracle on the seven decompiled files. The instructions I gave have only one possible answer: yes. That's the only part that will be granted.

That being said, you don't have the damage study that ties to that infringement.

[The judge explains that even though Oracle doesn't have any hope of showing non-trivial damages, he's going to do everything by the book and give them their chance in front of the jury, just to guarantee they have nothing to complain about on appeal. Oracle interjects periodically to complain, but the judge cuts him off every time. I wish I'd managed to transcribe his whole rant.]

Judge: The way this should work is we'll start the trial, you put in whatever you have you put in your expert reports, and you can't change them. Yours don't even come close to what you're asking for. It would be the height of ridiculousness to say that those nine lines, you get hundreds of millions of dollars.

We'll keep the jury here, you can put on your damages case, such as it is. I'll explain to the jury that you've got no evidence.

You've got to tie it in to the actual things they found infringement on, which is nine lines of code. If you can prove real damages on that, you're a great lawyer. [Smiles at Boies and Jacobs, standing side by side, so unclear which he is addressing.]

We'll let you pursue the drill, trying to struggle in front of the jury, if you think that'll help your willfullness case, go for it.

Oracle: [confers with Google lawyer Robert Van Nest]

Judge: Both of you have been putting in statements about what you would say to the jury, but I don't want to look at them until you have a stipulation.

Oracle: Second thing: trial exhibit 1131, Professor Mitchell's demonstrative. We'd like direction on trial testimony. Google intends to read testimony from Mr. Kurian, we designated completeness counters [?].

Judge: Wait, did I even say you can read from the testimony?

Google: Yes, you did [quotes judge].

Judge: Okay, I'll stand by that.

..

Judge: Mr. Kurian works for who?

Oracle: Oracle. He testified right after Mr. Ellison in the copyright case.

Judge: You want to start off by him testifying to what happened in some meeting, right?

Oracle: No, it's---

Judge: Yes, you are, it's right here!

...

Google: Withdraws 400.

...

Google: Trimmed witness list down, trying to finish this morning.

I move to strike a portion of Dr. Mitchell's testimony, about the HTC Droid Incredible, which is no longer in the case. The parties have agreed that the words HTC Droid Incredible should be stricken.

Oracle: Not quite. The Droid Incredible is in the case; he testified about the Droid Incredible 2. We agree that the latter should be stricken.

Google: Transcript says Droid Incredible.

Oracle: We'll try to work this out.

Judge: I want to emphasize that the things I said are out of the case, because of the disclosure problems earlier. I don't want either side trying to slip something in.

Google/Oracle: We can resolve this.

Google: [Gives their list of witnesses for the day] Following Mr. McFadden, we'll play the Gupta video, then Terence Parr, then Dr. August.

Judge: How come his report's so thin? [laughter]

Google: There's not much in it.

Jury enters.

Judge: So, you'll remember that Andrew McFadden is the witness on the stand. We're now on the defense case. The defense says there's a good chance they'll finish today, maybe all the evidence, but possibly we'll be going into Monday. Because of my schedule, though, we'll have to break around 12:15 pm today.

So, there we are. You're all there with your pens poised, ready to do a work of authorship. [laughter]

[Mr. McFadden is totally a programmer. He speaks precisely, and doesn't tolerate any incorrect terminology or vagueness. He embarasses both lawyers this way, but Oracle has the worst time of it. He describes everything in technical terms, without analogies and without much explanation.]

Andrew McFadden on the Stand, Questions by Google:

Google: Good morning, welcome back.

Yesterday we walked through a demonstrative about resolve.c. I want to change gears and talk about another functionality for resolution of methods in Android. Are you familiar with dexopt?

Mr. McFadden: Yes, I wrote it.

Google: Explain what it does to dex files?

Mr. McFadden: It generally prepares a dex file for execution. This requires extracting the dex file from the application package that was downloaded, attempting to verify that all the code is sound, then performing a set of static optimizations.

Google: When was this added to Android?

Mr. McFadden: It sort of evolved, rather than appearing all at once. Middle of 2006 or early 2007 is when most of it appeared.

Google: TX-735, we looked at this a bit yesterday. What does it describe?

Mr. McFadden: The Dalvik bytecode.

Google: Bullet point two from the bottom: when installed on a running system, some instructions may be altered, changing their format as an install-time static linking optimization. What is that? Why does it refer to dexopt as install-time static linking?

Mr. McFadden: Dexopt often runs at install time.

Google: Does it ever run at runtime?

Mr. McFadden: No.

Google: Is it dynamic optimization?

Mr. McFadden: No.

Google: Turn to page 6, bytecodes 52 through 5f: instanceop bytecodes.

Mr. McFadden: Correct.

Google: Remind the jury, what is field@CCCC?

Mr. McFadden: It's an operand in the instruction, an index value that identifies a location in the field table.

Google: Note "these opcodes are reasonable candidates for static linking", what is that?

Mr. McFadden: Replacing the CCCC value with a different value which allows you to short-circuit one of the steps you do when accessing a field.

Google: What in Android lets you do that?

Mr. McFadden: Don't understand.

Google: What program does this?

Mr. McFadden: Dexopt.

Google: TX-739, Dalvik Optimization and Verification with dexopt. Who wrote this?

Mr. McFadden: I did.

Google: Is this part of the specification for the Android program files that OEMs use? [pause, withdrawn]

Where can this documentation be found?

Mr. McFadden: In the Android source tree.

Google: Half way down this page, there's a bullet: bytecode optimization is important for speed and battery life. What is that?

Mr. McFadden: What we just looked at, replacing field@CCCC.

Google: What is quickened instructions?

Mr. McFadden: Replacing one opcode with a different one that performs the same operation but takes slightly different operands.

Google: Bottom of page 3, top of page 4: Some of these require information only available at runtime. What is that?

Mr. McFadden: This whole paragraph talks about optimization in general terms. That's referring to things that dexopt doesn't do.

Google: Others can be inferred statically when certain assumptions are made. What's that?

Mr. McFadden: Those are things dexopt can do.

Google: For virtual method calls, replace method index with vtable index. What's that, replacing one index with another index?

Mr. McFadden: How deeply should I explain?

Google: As not-deeply as possible. [laughter]

Mr. McFadden: Very similar to what we saw before. Similar operation on method invocation.

Google: For instance field get/put, replacing field index with byte offset, is that the same as TX-735? What is that?

Mr. McFadden: Again, this is that field@CCCC operand, replacing that value with a byte offset into an object.

Google: Again, what's the difference between an index and an offset?

Mr. McFadden: Almost nothing. In this case, the index is into a table; when I say offset, it's usually a byte offset, but it's still pretty much the same thing.

Google: You prepared a demonstrative for dexopt? Is it shorter?

Mr. McFadden: Much.

Google: A bit of code here: static linking using dexopt. Explain what this is, starting with line 1953 (rewrite iget/iput).

Mr. McFadden: That's the purpose of this function: rewrite iget/iput. The note is just a reminder of how the instruction is layed out in memory.

Google: Line 1963, what's that?

Mr. McFadden: That's the name of the method, and the arguments it takes.

Google: Line 1966: u2 fieldIdx = insns[1]; Can you decipher that?

Mr. McFadden: This takes the field index out of the instruction stream. It gets the field@CCCC value and puts it into fieldIdx.

Google: What's line 1970?

Mr. McFadden: Call to dvmOptResolveInstField, very similar to dvmResolveInstField, but it has to work differently. This is the variant used for optimization.

Google: Lines 1983/1984, what's here?

Mr. McFadden: This is the instruction rewriting. 1983 replaces opcode, e.g. iget replaced with iget-quick. 1984 field index replaced with byte offset.

Google: Line 1983, what does newOpc stand for?

Mr. McFadden: "New opcode".

Google: Going back to resolve.c from yesterday, what's on the left-hand side?

Mr. McFadden: The instruction stream.

Google: On the right?

Mr. McFadden: A whole bunch of data.

Google: What's number 21?

Mr. McFadden: A pointer to a field structure.

Google: How does dexopt use it?

Mr. McFadden: Well, it's going to follow that to get at the information about the field.

Google: What information does it use?

Mr. McFadden: The byte offset, 48 here.

Google: What happens in the conversion from iget to iget-quick?

Mr. McFadden: At this point, we replace the opcode and operand with the new value.

Google: Let me do that again: the 52 at the top left, the 52 at top left gets rewritten at 242.

Judge: Wait, how did that happen? Where did we get 242?

Mr. McFadden: From the very bottom of the code sample, just taking newOpc and using that to replace the opcode, changing it from iget to iget-quick.

Judge: I don't see 242 anywhere on the page, where did it come from?

Mr. McFadden: It's the opcode number.

Google: What instruction is 52?

Mr. McFadden: It's iget.

Google: What's the instruction number for iget-quick?

Mr. McFadden: Hopefully, 242. [He smiles, but no one laughs]

The dex optimizer knows the values of all the opcodes. It knows it'll take this 242 value and drop it in where the 52 was before.

Google: What happens with that 48 offset?

Mr. McFadden: It replaces the operand 01.

Google: [demonstrates with an animation showing the 48 moving into the opcode stream]

TX-739 refers to dexopt as a "back door" into the VM, on page 3. "The solution is to invoke a program called dexopt which is really a back door into the VM", what does that mean?

Mr. McFadden: Most of the Dalvik VM lives in a library. It's largely built as a shared library. I was trying to say that I'm reusing a lot of the code that's in the VM. But if you launch the VM, and you launch dexopt, they come in from different directions. If you launch the VM, you come in through the front door, dexopt comes through the back, but they have a lot of shared code.

Google: Do dexopt and resolve.c work differently?

Mr. McFadden: They do some very similar things. The actual resolution code, while not exactly the same, is very similar.

Google: Is that the demonstrative we looked at yesterday? Is that process generally the same in dexopt and resolve.c?

Mr. McFadden: Yes.

Google: TX-737. I think we looked at this yesterday as well. Statement on page 2 towards the bottom: "Arguments which indicate a literal constant pool index have the form kind@X. Similar to the representation of constant pool indices, there are also suggested (optional) forms that indicate prelinked offsets or indices." What's that?

Mr. McFadden: The format after dexopt has done its optimization.

Google: What is vtaboff?

Mr. McFadden: "vtable offset".

Google: fieldoff is field offset?

Mr. McFadden: Yes.

Google: What's iface?

Mr. McFadden: "Interface pool index".

Google: First paragraph talks about what a dex file looks like when it arrives on the phone?

Oracle: Objection, leading.

Judge: Don't lead.

Google: Okay, what does a dex file look like when it arrves on the device?

What does this paragraph "similar to the representation" refer to? What form of the dex file?

Mr. McFadden: Once you've got the instructions replaced, that's what we call an odex file, for "optimized dex".

Google: Is the second paragraph talking about the optimized file after it's been processed by dexopt?

Mr. McFadden: Yes.

Google: Section "the formats", opcode 22c "instance-of", what is this?

Mr. McFadden: The instruction format which, among other things, is used for iget and iput.

Google: Right below that, "22cs op vA, vB, fieldoff@CCCC", what's that?

Mr. McFadden: The format of the instructions after they've been quickened by dexopt.

Google: "Suggested format for statically linked field access instructions", what's that?

Mr. McFadden: For the optimizations dexopt does, that's the recommended format.

Google: And field@CCCC refers to the operand in the instruction stream?

Oracle: Leading.

Judge: Yes, that's leading. Sustained.

? Google: [long pause]

Judge: [prompting] "To what extent, if at all..."

Google: [collects himself] To what extent, if at all, does field@CCCC refer to the operand in the instruction stream when it arrives on the device?

Mr. McFadden: Sorry, I have no idea what you're asking. [laughter]

Google: Can you explain whether and how dexopt changes field@CCCC to fieldoff@CCCC?

Mr. McFadden: That's the code we were just looking at.

Google: To what extent, if at all, is fieldoff@CCCC a location in memory in the dex file?

Mr. McFadden: What does "location in memory in the dex file" mean? The file isn't in memory.

It does identify a location in the field table.

Google: Does fieldoff@CCCC identify a location?

Mr. McFadden: Yes, it's an offset into an object.

Google: No further questions.

Cross Examination of Mr. McFadden, by Oracle:
Oracle: Good morning. TX-735.

First page towards the bottom: "when installed on a running system, some instructions may be altered", is that dexopt?

Mr. McFadden: Yes.

Oracle: Instruction alteration referred to in TX-735 occurs during installation on a running system?

Mr. McFadden: Not necessarily.

Oracle: This passage reads "when installed on a running system". Is that accurate?

Mr. McFadden: It's true but incomplete. The instructions may be altered as the system is being built.

Oracle: On the developer side?

Mr. McFadden: Yes.

Oracle: dexopt running on an actual phone, that's on a running system?

Mr. McFadden: Yes.

Oracle: This instruction alteration is occurring during installation on a running system?

Mr. McFadden: Yes.

Oracle: "Faster execution once linkage is known", so dexopt instruction rewriting allows for faster execution?

Mr. McFadden: It can.

Oracle: This sentence is true?

Mr. McFadden: Yes.

Oracle: dexopt instruction rewriting can only be performed on a handset once linkage is known. True?

Mr. McFadden: True.

Oracle: Linkage can only be known on a running system.

Mr. McFadden: If you mean it's plugged in and turned on, I agree.

Oracle: I mean "running system" as expressed in this sentence.

Mr. McFadden: If it's plugged in and turned on, then it's a running system, so yes.

Oracle: Slide 20 from yesterday. You said what's shown here is a simplified description of a dex file, do you recall?

Mr. McFadden: This is more than just a dex file, because it includes the resolved fields table.

Oracle: The portion to the right is, by your testimony, a simplified description of a dex file?

Mr. McFadden: True.

Oracle: Just to explain again, a dex file is what's created by the operation on a "source code" file by the java compiler?

[He really did pronounce "source code" like it was in quotes.]

Mr. McFadden: I don't understand.

Oracle: The dex code is the bytecode version of the program, right?

Mr. McFadden: Yes.

Oracle: Someone wrote a program, ran it through the Java compiler, ran it through dex, installed it on the handset, that's how it got here, right?

Mr. McFadden: Yes.

Oracle: TX-736. Your document, ".dex -- Dalvik Executable Format".

Mr. McFadden: It's not actually my document.

Oracle: But you're familiar with it?

Mr. McFadden: Yes.

Oracle: You stand by it?

Mr. McFadden: Um... yes.

Oracle: This file describes the format of dex files, you stand by that?

Mr. McFadden: Yes.

Oracle: Second page of TX-736, "overall file layout". This is a depiction of the layout of the contents of a dex file, true?

Mr. McFadden: Yes.

Oracle: Nine sections, true?

Mr. McFadden: [counts] Yes.

Oracle: The field_id section is the field id table you testified about, true, sir?

Mr. McFadden: I believe so.

Oracle: The field id table listed under data is the second column in the green area, true?

Mr. McFadden: Yes.

Oracle: Under "data", that field id section is the fifth section of the overall file layout in the .dex file format, right?

Mr. McFadden: Yes.

Oracle: Other sections correspond to tables you testified about, true, sir?

Mr. McFadden: I believe so.

Oracle: The data section is the "data area containing all of the support data for the tables listed above", correct?

Mr. McFadden: Yes.

Oracle: So the field id table is not stored in the data area, true, sir?

Mr. McFadden: It's not stored in the section that's *labeled* data.

Oracle: This is Google's official definition of the dex file format, is it not?

Mr. McFadden: It is.

Oracle: The resolved fields table is not part of the dex file format, true? You didn't mean to convey to the jury that the resolved fields table was part of the data area, did you?

Mr. McFadden: No.

Oracle: Field index 01 here corresponds to a field named "fun" of type byte, is that correct?

This is a variable named "fun"?

Mr. McFadden: I wouldn't call it a variable. It's a field.

Oracle: The actual value could vary depending on the program, right?

Mr. McFadden: Yes.

[A little more arguing about nomenclature]

Oracle: To get this into the dex file, a programmer wrote something like y = fun + 2, right?

Mr. McFadden: [pauses]

Judge: Wait, what is fun? Is it a number or a string?

Mr. McFadden: "fun" is the name of a field.

Judge: Would it have a numerical value like 10, or a string value like your name? Mr. McFadden: Depends on how the class was declared. Every field has a type and a name. If I say it's an integer, it holds a number.

Judge: It would look exactly the same if it were a string?

Mr. McFadden: Yes.

Oracle: In the case at hand, fun will ultimately represent an integer value, right?

Let me back up. You referred yesterday to an "actual field value", do you recall?

Mr. McFadden: Not specifically, but I'll go with it.

Oracle: Fun has an actual field value?

Mr. McFadden: No, it's just a name. It doesn't have a value.

Oracle: The field that it refers to has a value?

Mr. McFadden: Yes.

I could have ten different classes with fields called "fun". They all use the same symbol, since symbols in a dex file are shared.

Oracle: What's the value of this field in this illustration?

Mr. McFadden: It doesn't have a value here.

Oracle: But it had one in what you showed yesterday, right?

Mr. McFadden: No, I don't think so.

Oracle: This happened because a programmer decides to name a field "fun". The programmer chose that name, we're just having fun here, so "fun" is our variable, right? [laughter]

Mr. McFadden: Yes.

Oracle: Exhibit 46.6.

Say you have an object with a "fun" field, storing the value 17. 52 is the iget instruction, right?

Mr. McFadden: Yes.

Oracle: Result would be the actual value 17, right?

Mr. McFadden: Yes.

Oracle: So the role of the iget instruction is to obtain actual field data from an object and store it in a Dalvik register, true, sir?

Mr. McFadden: Yes.

Oracle: iget with 01 as the field index, it doesn't store the number 01 in a Dalvik register, right?

Mr. McFadden: Right.

Oracle: It doesn't obtain 2 or 76 and store those in a Dalvik register, does it?

It doesn't obtain the name "byte", does it?

[five or six more questions along these lines, getting more and more excited]

Mr. McFadden: Yes.

Oracle: The actual data is what it stores, right?

Mr. McFadden: Yes.

Oracle: True or false: the Dalvik iget instruction never contains the actual memory location of the actual field it's supposed to get, true?

Mr. McFadden: True.

Oracle: True or false: the va operand is not the memory location of the actual field?

Mr. McFadden: True.

Oracle: The vb and field@CCCC are not the memory location of the actual field?

Mr. McFadden: True.

[By this point the Oracle lawyer looks like he's just triumphantly unveiled the murder weapon. I have no idea what his questions were supposed to mean, though, and the witness sounded like he didn't either. I didn't see the jury's response.]

[PJ: All the questions from Oracle are designed to prove that Google infringed one of its patents; all the Google questions are designed to show that Google used a different method and that Android uses a different technology. See Update 3 from Tuesday's coverage.]

Redirect Examination of Mr. McFadden, by Google:

Google: Let's go back to TX-735. "When installed on a running system", what does this mean by "running system"?

Mr. McFadden: It's the basic definition of "running": power is turned on, batteries inserted.

Google: Does this mean the system is executing Dalvik bytecode?

Mr. McFadden: Not necessarily.

Google: Lot of discussion of running and runtime. Is dexopt a static or dynamic optimizer?

Mr. McFadden: Static.

Google: Why is it called that?

Mr. McFadden: Because it doesn't require information that's only available at runtime.

Google: In what sense do you mean "runtime"?

Mr. McFadden: There's compile time, when compiler and dex are running, install time when you download to the device, runtime when the application itself is executing.

Google: Does dexopt operate when the application itself is running?

Mr. McFadden: No.

Google: Is that why you say it's not a dynamic process?

Mr. McFadden: Yes.

Google: Slide 20. Did you intend this to map exactly to exhibit 736?

Mr. McFadden: It doesn't exactly match anything.

Google: Why did you use the term "data" here?

Mr. McFadden: To contrast with the instruction stream.

Google: Is the instruction stream separate from the data?

Oracle: Leading.

Judge: Try not to lead.

Google: To what extent are the instructions and tables separate in the dex file?

Mr. McFadden: A lot of things are interleaved, but the instructions for a given method are distinct. They occur in a solid block inside the dex file, so you can find a chunk which is the instructions for a given method.

Google: Page 17, "insns", is that the chunk you were referring to?

Mr. McFadden: Yes.

Google: Slide 21. Mr. Jacobs asked if "1" in the instruction stream corresponds to "fun", remember that?

Mr. McFadden: I think so.

Google: What does "1" tell you?

Mr. McFadden: Index into the field IDs table.

Google: Does it tell you a location?

Mr. McFadden: Yes.

Google: What happens when you get to location 1 in the field table?

Mr. McFadden: You read the data there, and chase that to the next location.

Google: What happens when you reach the string data table?

Mr. McFadden: At that point, you're no longer working with numeric values; you've got string data, and you have to use those to find a matching field.

[More leading questions, shut down by the judge again]

Google: What's the difference between a reference where you use a symbol like this, and reference using numeric values?

Mr. McFadden: Numeric references take you directly to the next place you need to be. Symbolic references like "fun" don't give you an address, you have to take them and compare them against something else. You need to find the field that matches them. You can't just go straight there, you have to search for it.

ReCross Examination of Mr. McFadden by Oracle:
Oracle: TX-739, page 3. "When dexopt runs, it has loaded the application it is optimizing into the Dalvik VM".

Google: Beyond the scope of my redirect.

Oracle: It's about dynamic.

Judge: Okay.

Mr. McFadden: For a limited definition of "Dalvik VM", yes.

Oracle: When dexopt runs, it depends on information about the config of the handset, true?

Mr. McFadden: Yes.

Oracle: When updates are sent to the handset, you have to rerun dexopt, right?

Mr. McFadden: Yes.

Oracle: So it's like when a courtroom is reconfigured, and you have to change references from courtroom 8 to courtroom 9, it's like that?

[The analogy is discussed and subsequently abandoned]

Oracle: The layout of the memory that Dalvik uses changes from time to time, right?

Mr. McFadden: I'm not comfortable with "layout of the memory".

Oracle: The locations of actual field values changes?

Mr. McFadden: [pause] The actual location of field values is not known to dexopt.

Oracle: Not known to dexopt? [pause] But dexopt resolves symbolic references into numeric references?

Mr. McFadden: True.

Oracle: Because that process depends on the configuration of the handset, it's dynamic, true?

Mr. McFadden: No.

Oracle: Because the process depends on the configuration, which can change from time to time, it's dynamic, true?

Mr. McFadden: I guess.

ReReDirect of Mr. McFadden by Google:
Google: You struggled to answer whether the data exists at the time of dexopt, why?

Mr. McFadden: While dexopt is running the application is not runnning, so to talk about the objects or field contents doesn't make any sense. The application can't have created any objects beacuse it's not actually executing.

Google: Do the objects exist at the time dexopt is running?

Mr. McFadden: No.

[witness steps down]

Google: We'll play video from Gupta.

Judge: How long? 10 minutes?

Google: 8 minutes.

Video of Gupta deposition:

Q: State your name.

A: Vineet Gupta.

Q: Former employee of Sun?

A: Yes, started in 1997.

Q: You remained a Sun employee until Sun was acquired by Oracle, and are an employee of Oracle now?

A: No, I left on June 1, 2011.

Q: At Sun, when did you join the team that developed licensing strategy for Java?

A: Don't remember, too long ago.

Q: Before 2005?

A: Yes, I think so.

Q: Google/Sun discussions?

A: We had been talking to Andy as part of Android before, tried to figure out new direction based on Google's requirements, how we'd make that work within the confines of what we thought would be sellable to the two companies. Definitely out of the box.

Q: Other people at Sun participated?

A: Alan Brenner, Eric Chu, Tim Lindholm... over time, when Brenner left, Laurie Tolsen, Ann McLaughlen, Mark Marquis...

Q: Who was the primary negotiator?

A: Started with me and Andy Rubin, grew into a team when Alan Brenner wanted to take charge and he became the primary negotiator.

Q: On other side, Andy Rubin was the main negotiator?

A: Yes. Also Rich Miner joined for a while... Richard Beardsley maybe?

Q: Did patents ever come up?

A: Specifically patents? No. We always discussed partnership that encompassed everything. Not an adversarial situation.

Q: You didn't mention any Java-related patents to Google?

A: I personally did not.

Q: Email to Rich Green, May 2006:
"Andy informed me he's been asked by his GC to hold off any meetings until the patent issue is resolved." What is that?

A: What I heard from Google, there were some patent attorneys from Sun who had approached them on patents that had nothing to do with Java or StarOffice that they were looking at licensing to Google.

[end of video]

Google calls Terence Parr:
[sworn in]

Google: What do you do for a living?

Mr. Parr: Professor and grad program director at USF. Bachelor's in CS and PhD in computer engineering at Purdue. Worked at the Army High-Performance Computing Research Center at University of Minnesota.

Google: Familiar with Java?

Mr. Parr: Yes, written hundreds of thousands of lines, starting even before the formal announcement of Java.

I moved to San Francisco because I thought something exciting was going to happen with Java and the Internet, in 1995.

Within a few months I started a company called jguru, which would help big companies like Microsoft and FedEx retool their engineers, retraining them from C++ to Java.

Google: Who wrote the server that ran that website?

Mr. Parr: I did, 100k to 150k lines of code.

Google: What experience do you have with virtual machines?

Mr. Parr: I teach how to build them in grad and undergrad classes, dozens of them. One of the biggest was for Renault Automation; I worked in Paris for a while to produce a compiler, debugger, and virtual machine that was fundamentally the same as the Java virtual machine.

Google: Written any books?

Mr. Parr: Three books on language implementation and parsing, working on a fourth.

I'm best known for a tool called ANTLR, used by major companies, comes on every Linux machine, widely used. Helps programmers build parsers.

Google: TX-2672, what is this?

Mr. Parr: It's my CV. Long boring list of my education, etc. [PJ: here.]

[CV entered as evidence, qualified as expert on computer science, no objections]

Google: TX-4011, US patent 6,061,520. Are you familiar with this?

Mr. Parr: Yes.

Google: Can you explain the background of the patent? Statically initialize an array? What's an array?

Mr. Parr: It's just a list of memory cells where you can put things.

Google: What's generally contained in an array?

Mr. Parr: Could be lots of things, but generally just numbers. To create an array means to allocate space within the memory for these cells. To initialize means to specify the default value.

Google: What does it mean to execute a program?

Mr. Parr: It's like when you launch Microsoft Word, or when you click an app on your phone to start it up.

Google: [Slide showing Java bytecode to initialize an array] What does this show?

Mr. Parr: On the left, Java code "static int[] tester = {1, 2, 3, 4};" defines an array called "tester" with four initial values. On the right is a depiction of the Java compiler, which grinds away on that source code and generates the instructions you see.

At address 0, "iconst_4" pushes the value 4 on the stack.
A stack is a scratchpad for a stack machine. Every instruction you see manipulates the stack in some way.

Imagine we want to add 1 and 2. Imagine a stack of plates. I push a "1" plate on the stack -- think of a place with "1" written on it. Then a "2" plate. Then to perform the addition, I pop those plates, and put a "3" plate there instead.

Judge: Is there a reason the numbering of the opcodes skips 1?

Mr. Parr: Good question. It's basically the address, and some instructions take more space than the others. For example, the "dup" instruction takes one byte, so it's at address 3 and the next is at address 4. Imagine going down the street, some people have a big fancy house and it takes up a lot of space, some people have small houses. The more information you have to pack into the instruction, the more space it takes.

Judge: I still don't udnerstand why there's no address 1.

Mr. Parr: The iconst_4 instruction occupies both address 0 and address 1.

Judge: Ah, okay.

Mr. Parr: Second instruction: newarray int. Pops the value 4, then creates an array with 4 elements in it, and "int" means the elements are numbers. Now I've replaced that 4 with a reference to the array.

Third instruction: dup. Here we move from array creation to array initialization. If we got rid of the "= {1, 2, 3, 4}", then most of the rest of this code would disappear. But for the purpose of initializing this static array, the Java compiler inserts a sequence of instructions that individually assign values to the slots in the array.

[Explains in detail the process of initializing an array in java bytecode]

Judge: All those bytecodes are created by the Java compiler, right? Does Oracle make the only Java compiler?

Google: No, there are several others: gcj, Jikes, etc.

[Judge announces 15-minute break]

Mr. Parr: May I sit down?

Judge: You may. You can have a 15-minute break, too.

[break]

And here's part two:
Fri May 11 09:30:53 PDT 2012

After and During the Break, the Judge and the Lawyers Confer:

Oracle: Van Nest and I continue to work on phase 3 issues, we've agreed that both copyright willfulness and patent willfulness will be tried in phase 2. Consequences: we'll need to work on the instructions and verdict form.

Our current thinking is that the trial plan remains as is. His case-in-chief will be a very brief rebuttal. If I've anticipated incorrectly and I need more time to respond to his rebuttal, then he'd get more time too.

We're talking about willfulness [...]

Judge: Are you suggesting you'd reopen the case to put in more willfulness evidence?

Oracle: No, just rebuttal to what Google might do in its current defense case-in-chief. If in our rebuttal we end up having to do more than we anticipate on willfulness, then they'll have a chance to respond.

Judge: Do you want to adjust the hours?

Oracle: No, I think we have time.

Judge: [to Van Nest] Do you agree?

Google: Just about. I think we have an argument we need to discuss, that there's no remaining claim for willful copyright infringement, but apart from that, I'm in agreement. I still think it's likely we'll finish most of the evidence today, with closings or part of them on Monday.

Judge: Willfulness on copyright: that could only be for rangeCheck and the decompiled code. Is plaintiff seeking willfulness for those two items?

Oracle: Yes.

Judge: How do we deal with that?

Google: Willfulness is only an issue in copyright for statutory damages. If they're not seeking statutory damages anymore, then willfulness isn't relevant there. We'd just be trying patent willfulness along with willful blindness.

Judge: Is that how it works?

Oracle: [Boies] There's an issue with willfulness [...] [some sort of split between different courts, apparently some of them think willfulness can be relevant to infringer's profits]

[PJ: Here's what they are talking about when they say "infringer's profits". The remedies section of copyright law goes like this:

(b) Actual Damages and Profits.— The copyright owner is entitled to recover the actual damages suffered by him or her as a result of the infringement, and any profits of the infringer that are attributable to the infringement and are not taken into account in computing the actual damages. In establishing the infringer’s profits, the copyright owner is required to present proof only of the infringer’s gross revenue, and the infringer is required to prove his or her deductible expenses and the elements of profit attributable to factors other than the copyrighted work.
In short, this is about Google having to spend more money to prove its profits from Android don't come from some test files that aren't even in Android plus rangeCheck. It's on the mean side, in my view, in a fact pattern like this. They don't think they can prove specific damages, but they seem to hope that Google won't be able to prove specifically that their profits don't come from this source, and will therefore maybe throw out a figure that looks less stupid than the $150,000 that Oracle otherwise is limited to for rangeCheck and some other tiny figure for the test files. In other words, it's a gamble, but they have so little to lose, they figure they can try for millions through this lawyer trick.]

We don't believe it's possible to tie specific damages to rangeCheck or to these files. The only issue is whether we're entitled to make an infringer's profits case. We're saying once you have proved infringement, we think we have a claim for infringer's profits, and the burden of proof is on them. The question is not how much we're entitled to, it's who has the burden.

We're not going to have proof of damages, because we're not claiming damages. It's going to be infringer's profits.

If given the relative contribution of these items to Android, there's an inability for us to seek infringer's profits, then there's no need for a trial. But if the court sees our case--

Judge: I said, you can make your pitch to the jury. This is being sprung on me... if you want to say to the jury that you're asking for hundreds of millions of dollars for nine lines of code, you can do that if you want. I'm not going to blurt out some ruling now. I took back what I said yesterday: if you want to make out a case for infringer's profits based on nine lines of code and seven files that aren't even part of the Android system, well, that's an extremely weak proposition, but I can't tell you it's illegal as a matter of law. It could be I'd be surprised by some statement in a decision somewhere.

Google: I don't think you'll be a bit surprised, Your Honor.

Judge: Well, then you can brief it for me. But in the meantime, we're going to have phase 3.

See, your stipulation is falling apart, beacuse you can't agree on whether willfulness has any effect on the copyright side. If you can agree on exactly what you mean, we can alter the jury instructions. But until you can agree on that, we won't change anything. I see 95% agreement now, not 100%.

Oracle: I think that's exactly right, Your Honor.

Terence Parr returns to the courtroom.

Terence Parr on the Stand, Google Asking the Questions:

Google: Dr. Parr, could you look at the '520 patent, claim 1, which Oracle is asserting in this case?

Taking a look at claim 1, explain what the steps in claim 1 do?

Mr. Parr: The first step is where it says "compiling source code containing the array with static values". That's the Java compilation process we talked about, where you take human-readable source code and compile it to Java bytecode. The second step, "receiving the class file into the preloader"... [basically reads the claim]

Google: What does the patent say about the clinit method you refer to? I might direct you to column 1 of the patent, around line 257.

Mr. Parr: The clinit method stands for "class initialization method". Its job is to initialize all the static elements in a class, including static arrays.

Google: In claim 1, what is "simulating execution of the bytecodes"?

Mr. Parr: I understand "execution" to mean running live on the JVM. Simulating execution is in the preloader -- it's like a dress rehearsal versus a live show. The goal is to simulate these bytecodes to determine the static initialization of the array.

Google: What's the core requirement for simulating execution on a stack machine?

Mr. Parr: Well, you need to manipulate the stack -- pushing, popping, etc.

Google: Is this described in the patent?

Mr. Parr: It does not say stack manipulation.

[Shows how the example code in the patent is operating on a stack]

"Object stack[] = new Object[stackSize]; // create stack for play execution" etc.

Google: Were you in court for Dr. Mitchell's testimony on infringement?

Mr. Parr: Yes.

Google: Do you agree with his testimony?

Mr. Parr: No.

Google: Why not?

Mr. Parr: Because dexopt doesn't use simulated execution for the purpose of determining static initialization of the array.

Google: How did you determine that?

Mr. Parr: Spent a long time looking at the dex source, running tests, etc.

Google: What's the purpose of the Android dex tool?

Mr. Parr: It takes the .class files emitted by the Java compiler, and translates them to .dex files.

The Java Virtual Machine and the Dalvik VM have completely different instruction sets, so a translation has to occur. Otherwise it's like a person who only speaks German giving instructions to someone who only speaks Portuguese.

Google: So how can Java programs run on Android?

Mr. Parr: That's what dex does. It translates Java bytecodes into Android bytecodes, so Android can execute them.

[Discussion about how dex uses simulated execution, as described extensively in its comments.]

Google: So you'd agree that the Simulator class does know how to simulate bytecodes?

Mr. Parr: Yes.

Google: So why doesn't it infringe the '520 patent?

Mr. Parr: That's because for the very specific purpose of identifying the static initialization of the array, it does something different -- it uses pattern matching.

Google: What does "identify static initialization of the array" mean?

Mr. Parr: It means to find the values that will be used to initialize the array.

Google: TX-46.17. What is that?

Mr. Parr: BytecodeArray.java. It appears to be from froyo. It's part of dex.

Google: You've looked at it before?

Mr. Parr: Yes.

Google: Where does it come from?

Mr. Parr: From the dex tool.

Google: What did you find that's relevant to your opinion?

Mr. Parr: What I identified was the specific part of the program, dex, that identified the static initialization of the array. It's in parseNewarray, line 887.

Actually, easiest is if you turn to line 948, there's a comment: "Try to match the array initialization idiom. For example, if the subsequent code is initializing an int array, we are expecting the following pattern repeatedly" -- and then you see the pattern we saw earlier, for how to initialize an array. It appeared to me to be a classic example of a pattern matcher.

Google: How do you know?

Mr. Parr: Well, I've been building parsers for 30 years. See line 965, it defines a variable called "punt" -- it's looking for something, if it doesn't find it, it fails. It's a classic example of pattern recognition.

Google: Is it manipulating the stack at all here?

Mr. Parr: No, I didn't see any stack manipulation.

Google: What are comments for?

Mr. Parr: They help future developers, or ourselves, understand what the developer was thinking.

Google: Did you find the comments consistent with what the code actually does?

Mr. Parr: I did.

Google: What experiments did you use to test your hypothesis that this was using pattern matching?

Mr. Parr: Well, first I did a simple test to see that there were no stack manipulations in the static array initialization. I put print statements in the stack manipulation instructions (push, pop), like an alarm, so they'd trigger if there was any stack manipulation. I didn't see any.

[Demonstrative, titled "parseNewarray does not use the stack", showing the output of running the program with his debug prints added]

...

During the normal operation of the simulated execution, we see stack manipulation. But as we enter the parseNewarray method, what I observed is the stack alarms went silent until the parseNewarray method had exited. But once we returned from parseNewarray, we again got stack manipulations.

Since there are no stack manipulations, it can't be using simulated execution to identify these initialization.

Google: What was the second experiment you performed?

Mr. Parr: Well, this one's a little trickier, but useful. If it were using pattern matching, then if the pattern of initializations were altered, the pattern would fail to match. But if it were using simulated execution, then a minor change wouldn't affect it and it would still work.

For example, if I say "I like apples" and someone else says "I *totally* like apples" [...]

[Starts drawing pictures for the jury; he's totally in lecture mode now]

Here are the initialization elements of the array. This is human- readable code that the compiler consumes and uses to generate bytecodes. Let's see what the bytecodes will look like.

[Very detailed description of exactly how to initialize an array in java bytecodes, to which most of the jury is remarkably attentive.]

So, this is the pattern I'm talking about: dup, iconst, iconst, store.

[Shows the pattern again for initializing the second array element.]

Google: So, at that point, what did you do to change the pattern?

Mr. Parr: First, I ran dexopt on this sequence, generated by the compiler. It does indeed create an instruction to initialize this array, all in one go. So the default output of the compiler is recognized by the dex tool as static initialization.

So, how can I change this sequence of instructions without modifying the end result? Remember a new array is already initialized to zero. I'm just going to add an extra instruction at the beginning to set it to zero again. This is a tweak that doesn't affect the code; if it executes, it wouldn't change the end array. However, if the dex tool is a pattern matcher, it'll fail to recognize this pattern.

I ran the dex tool on this modified bytecode stream, and the dex tool failed to generate an instruction to initialize these elements in one go.

Google: Professor Parr, could you show the slides you prepared?

Mr. Parr: [Shows slides comparing original bytecode with his modified bytecode that adds an extra redundant store of zero.]

You can see these extra instructions don't change anything, since that zero is already there.

Here are the Dalvik bytecode instructions created by the dex tool in response to the original bytecode sequence: it uses fill-array-data.

But with the modified code, there's no fill-array-data to initialize the array in one go. You see the normal conversion of Java bytecodes to Dalvik instructions (new-array, aput, etc.).

Google: If the dex tool were in fact simulating the execution of the Java bytecode, what would have resulted?

Mr. Parr: If it were simulating, it wouldn't care about the extra instruction.

Think of it this way. Imagine we want to match a pattern of any two numbers added together, like "1 + 2" or "3 + 4". A functionally equivalent instruction is "0 + 1 + 2" -- but it breaks the pattern of "any two numbers added together".

Google: So, what element of the patent is not found in what the dex tool does, in your opinion?

Mr. Parr: Well, it specifically requires simulated execution, but the dex tool does not use simulated execution for the purpose of static array initialization.

Claim 20: "Simulating execution of the code to identify the static initialization of the array".

Google: Were you present for Mr. Poor's testimony? Did you have an opinion?

Mr. Parr: Yes, I disagree with his conclusions; his tests weren't on real- world applications.

His tests were contrived examples which were not meant to be real- world examples. The impact of a patent -- you want to see how it's affecting real-world applications, because that's where the value is, I guess.

Google: Did you perform your own analysis of the potential impact of this functionality?

Mr. Parr: I analyzed about 20 real-world applications for the Android phone, to see what the impact was of generating this fill-array-data instruction. I determined how many arrays were used in the original program, how big the space was that they needed, and computed a percentage that indicated what percentage of the .dex file is consumed by these instructions.

Google: Where did you get these applications?

Mr. Parr: I got them from counsel.

[Applications are BooksPhone, GenieWidget, Gmail, GoogleBackupTransport, GoogleCalendarSyncAdapter, etc.]

[Shows slide with .dex file size, and the percentage of bytes in each file which are taken up by static arrays. It's around 0.05% on average, and zero for several.]

Google: Given that finding, what's your analysis of the impact of the accused functionality on an ordinary Android application?

Mr. Parr: From my experience and examining these applications, these are just not a problem.

Google: So, to summarize, what's your opinion on the '520 patent?

Mr. Parr: The dex tool uses pattern matching, not simulated execution, the reason being that it does not use a stack.

Cross Examination of Dr. Parr by Oracle:
Oracle: Good morning, sir.

Mr. Parr: Good morning.

Oracle: Are you saying that the accused functionality in the dex tool is valueless?

Mr. Parr: Its overall impact on real-world applications is insignificant. It's greater than zero, but it's near zero. Statistically speaking, it doesn't affect the application size in any significant way.

Oracle: So the Google developers developed functionality with near-zero real-world significance?

Mr. Parr: Programmers have an instinct to optimize stuff, they remember old systems where it mattered.

I don't remember how big Mr. Bornstein said the libraries were -- 10 megabytes? 20 megabytes? This is 100,000 vs. 10 million. Not totally insignificant, but not huge.

Oracle: And this is still in the dex tool today?

Mr. Parr: I believe so.

Oracle: Your testimony is, if a developer decided to remove the code, it would have an insignificant impact on the real-world performance of the phone?

Mr. Parr: Yes. In fact, I think one of the Google engineers said this wasn't even in the code originally.

Oracle: So it got added in? Someone made an affirmative decision to add it to the code?

Mr. Parr: Sure. Basically, you develop software not in one big lump; you do the high-priority items, then you eventually get to the low-priority items.

Oracle: So this must have been a low-priority item for the Google developers?

Mr. Parr: I assume so. I mean, I don't know what they were thinking.

Oracle: You didn't make your own independent choice of applications to test this?

Mr. Parr: No, unfortunately I have an iPhone -- well, I should say fortunately. [laughter]

I tried to download applications from the Android store, but it wanted a phone ID.

Oracle: So counsel gave you the applications you tested?

Mr. Parr: Yes. But I can only imagine that applications like Gmail, Maps, Street View, etc. are fairly popular and real-world.

Oracle: You didn't test the Android code itself?

Mr. Parr: I did not take the entire source base and perform an analysis.

Oracle: So if either there were real-world applications you didn't test or parts of the Android platform itself you didn't test, you could have missed part of the value of the patent?

...

Oracle: You could make an application that relied heavily on static array initialization -- a real-world application, even.

Mr. Parr: Sure. That's what [someone] did.

...

Oracle: For claim 1, you acknowledge that the code is statically initializing an array, yes?

Mr. Parr: Yes.

[Showing that the dex tool satisfies the requirements of claim 1, except for simulated execution; Parr agrees]

Oracle: You agree that there is an identification of the static initialization of the array in the dex tool?

Mr. Parr: Yes.

Oracle: [Marks off those words in the patent] We also agree that it does so without executing the bytecodes, true?

Mr. Parr: I interpret "executing the bytecodes" in this context to mean on the live Dalvik VM.

Oracle: And it isn't doing that, so you agree with me?

Mr. Parr: Yes.

Oracle: And this is directed to the bytecodes of the clinit method? [He pronounces it as "cli-nit", and Parr corrects him.]

Mr. Parr: Yes.

[They agree that the dex tool does use simulated execution of bytecodes in other contexts, but not here.]

Oracle: But you say the dex tool does not use simulated execution for the purpose of static array initialization, yes?

Mr. Parr: Yes. The dex tool uses pattern matching, as I described. It does not represent simulated execution of those bytecodes.

Oracle: Because according to you, that has to be done on a stack machine, against a stack?

Mr. Parr: Yes. The only meaningful definition of simulated execution on a stack machine is manipulation of a stack.

The dex tool does not manipulate the Java stack, if you will, while it determines these static initialization elements.

Oracle: Even though the word "stack" appears nowhere in this claim, it's your contention that this claim requires the use of a stack?

Mr. Parr: Yes, and the reason I think that--

Oracle: That's enough; your counsel will have a chance to ask about that.

Let's look again at line 37.

Mr. Parr: My favorite line. [chuckles]

Oracle: Well, it's my favorite, I don't know if it'll be your favorite after this.

So this class says it knows how to simulate the effects of executing bytecode. You would agree that this class simulates the execution of bytecodes?

Mr. Parr: Yes.

Oracle: Line 110, the word "simulate" appears again. "Simulates the effect of the instruction at the given offset ..." That is the word that the engineer chose to use.

Mr. Parr: Yes, but I'd point out that-- [Oracle lawyer interrupts] Sorry, sorry.

Oracle: [Points out lots more places in the code that refers to simulating execution; Parr agrees]

Oracle: So when the dex tool receives the bytecodes to initialize an array, you agree that the class Simulator will visit those bytecodes? You said it visits the first two bytecodes.

Mr. Parr: As part of array creation and initialization, yes.

Redirect of Dr. Parr, by Google
Google: You got some questions from Mr. Jacobs about the applications you looked at, right? [something about the Mitchell report]

Mr. Parr: I don't remember seeing an analysis of real-world applications by Prof. Mitchell.

Google: You were shown some parts of the Simulator class. When you have the Simulator class, and it uses parseInstruction, what does that parseInstruction do?

Mr. Parr: It decodes the individual bytecodes. As Your Honor asked earlier, why does it skip from 0 to 2, it's because it has to occupy two positions. parseInstruction decodes those.

Google: Does parseInstruction lead to another class?

Mr. Parr: [pause] Yes, you're calling that method on a BytecodeArray.

Google: Is parseNewarray called by things other than the simulator?

Mr. Parr: Yes, it's used by at least two things: the basic block identification, and something called dex dumper. Neither of those have anything to do with the simulator.

Google: Visiting the first two bytecode instructions. Did those instructions identify the initialization of the array?

Mr. Parr: No. Those are the instructions for creating the array.

ReCross of Dr. Parr by Oracle:
Oracle: [I didn't understand this at all. The Oracle lawyer pulled up the same debug trace that Parr used earlier to show that there are no stack operations in the array initialization, and he started literally reading the debug messages from that log. Then he looked at Parr accusingly, and said something like "is that correct?"]

Mr. Parr: Yes.

Oracle: [triumphantly] No further questions.

The next witness: David August.

David August Testimony, Google's Witness:

Google: Can you briefly describe your educational background for the jury?

Mr. August: Sure. 1993 BS in electrical engineering--

Judge: You can look at the jury, that's cool, but you have to talk into the mic.

Mr. August: Sorry. In 1993 I earned a BS in EE from Rensler Polytechnic. 1996 Master's from UIUC, later PhD. Now professor of CS at Princeton. Started as a lecturer, promoted to assistant professor, then associate professor, served as associate chair of the department.

I generally teach courses and I do research. I teach compilers and computer architecture courses, for undergrads and grads. I also teach intro CS for freshmen, which involves Java.

For research, I direct a team of about a dozen grad students, in the area of architecture and compilers.

In 1994 I worked at Intel on microprocessor verification; in 1995 I went to HP to work on some of their compilers. 1996 back to Intel to help extend a compiler developed at Illinois. [more work experience in compilers]

Authored more than 80 papers. Member of IEEE and ACM. One issued patent, on compiler optimization.

Google: Tender him as an expert.

Judge: Very well, proceed.

Google: Were you retained by Google to provide an independent opinion in this case?

Mr. August: Yes. I was asked to look at the devices and give an opinion on infringement of the '104 patent. I have no financial interest in the outcome of this litigation.

Google: Did you see Mitchell's report that Android's resolve.c infringes [claim numbers] of the '104 patent?

Mr. August: Yes. I believe it doesn't infringe [claims].

Resolve.c operates on instructions that contain references. The '104 patent requires that those references be symbolic references, but resolve.c doesn't do that.

I believe dexopt does not infringe claims 27 or 49 [?] of the '104 patent. They require that the instructions contain symbolic references, but dexopt doesn't operate on instructions that contain symbolic references. Also, dexopt is a static process, and the claims require that this occurs dynamically instead of statically.

A bit of background: data, instructions, and resolution. You've heard a lot about them, and I'd like to review.

Three kinds of data: non-reference data, numeric references, and symbolic references.

Non-reference data is data that doesn't refer to other data. In this example from the '104 patent, there are two numbers, 23 and 17, and they're really just numbers. They don't refer to any other data.

A numeric reference refers to other data by its location. In this example, the "2" operand refers to some other data in slot 2 of the data object by its actual location in memory.

A symbolic reference refers to other data by a name. That name is not its location; in this case, that name is "y", but that doesn't give us any information about the data's location. You need to do a step called "resolution", where you take the name and convert it to a location. In this case, we might search the object for the data labelled "y". After some resolution, "y" is understood to be that second slot containing 17.

An instruction is a small step that instructs the virtual machine what to do. It might tell the virtual machine to fetch some data, or do an addition or a subtraction. It's a very small part of a larger program.

Instructions contain opcodes and operands. An opcode describe the primary functionality of the instructions -- addition, subtraction, get, etc. An operand modifies the operation: in the case of the add, what do we want to add? In the case of the get, what do we want to get, where do we want to get it from?

The "load 2" in the patent is an example of an instruction. Here, it has the opcode "load", and a single operand, 2. In this case, it indicates where to load the data; it's a location, a numeric reference.

"load r1, 3" is similar. It's for a register-based architecture rather than a stack-based architecture. The system will go to location 3 and put that value in register r1.

"load r1, 'y'" means we don't know where the data is. We know it's named "y", so we need to perform resolution. We search through the slots, and we eventually find slot 2, which has the name "y"; then we load that data, and put it in r1.

"add r1, 2, 2" is an example of an instruction that doesn't contain a reference of any kind. The 2 here is just a number; we're adding 2 + 2, and we'll get 4. We put the result into register r1.

A computer program contains instruction sequences, and also data. One instruction typically doesn't make an entire program; it'll contain many tens, hundreds, thousands of instructions. You don't want to just add, you want to play Angry Birds or something. You have to do a lot of math.

Resolution is the process of converting symbolic references to numeric memory locations. It may involve a search or other process to find the numeric memory location.

[Slide with example of resolution]

Judge: Hmm, what if "y" was the very last one you checked?

Mr. August: Yes, that's exactly the problem with symbolic references: it can take a long time to find the location you're looking for.

Judge: In this example, you just have five positions. In real life, would there be five hundred, five million?

Mr. August: Anywhere from one to millions. It depends on what the program is doing. It could be thousands, maybe tens of thousands in some cases.

It is limited by the programmer and the program. In this case, the programmer had to type "y", so the programmer will only make so many symbolic references.

Judge: Could you have one column for the "y"s, and another one for the "z"s, so you wouldn't have to search all of them?

Mr. August: Yes, that's an important example of an optimization. You could sort the references, and that would make it much faster to find the reference you want.

[A quick exchange that I missed]

Judge: Er, what does that mean?

Mr. August: I'm saying you're a good computer scientist.

Judge: Well, thank you.

Mr. August: You know, they're hiring at Google. [laughter]

[More description of symbolic vs. numeric references; analogy of "White House" vs. "1600 Pennsylvania Avenue"]

Google: Okay, let's talk about the '104 patent.

Mr. August: It describes a way of executing instructions that contain symbolic references.

Figure 8 shows how to handle a symbolic reference inside a "load" instruction, and how to improve its performance. The steps involve resolving the reference "y", finding its location (in this case, slot 2), and remembering its location by overwriting the instruction "load 'y'" with "load 2".

The claims require that the symbolic references be inside the instruction.

Claim 11: "instructions containing one or more symbolic references".

Google: To what extent is that requirement also reflected in figure 8?

Mr. August: We see it throughout the patent. It's in the figures, it's in the claims, etc.

Google: Are you familiar with the Android code accused of infringing?

Mr. August: Yes, I'm very familiar.

Google: How much time have you spent viewing the code?

Mr. August: In relation to this case, more than 50 hours.

Google: Are you familiar with the format of dex files? What is it?

Mr. August: It's a Dalvik VM program file, containing both instructions and data which instruct the program how to perform an operation.

They contain symbolic references, but they're not inside instructions. You'll find plenty of symbolic references outside of instructions, but not inside instructions.

Mr. McFadden did a great job of explaining how resolve.c works at a high level.

...

I looked at the court's claim construction order: "a symbolic reference is a reference that identifies data by a name other than the numeric memory location of the data, and that is resolved dynamically rather than statically".

The Dalvik VM does not operate on instructions that contain symbolic references.

[Points out the instruction stream in McFadden's demonstrative slides, which doesn't contain any symbols]

Google: Where are the symbolic references in this figure?

Mr. August: You see some here in the string data table. "fun" was the example that was covered most heavily.

Google: To what extent does the 1 in the instruction stream represent the symbol "fun"?

Mr. August: It doesn't represent it; it gives its location. The 1 indicates that in the field ID table we'll find other data, in location 1. In this case, the other data is two pieces: there's a 02, which is a numeric reference (the location of more data), and the 76, which is another numeric reference. Those are known as indexes. It's another way of saying its location in the table.

The 02 is referring to another index, in the string ID table, which gives you 08, yet another index. This one's in the string data table, which gives the actual symbol.

Google: What's the difference between an index and an offset?

Mr. August: They're often used interchangeably. They're both numeric memory locations. In Dalvik, you might use "offset" to mean an offset from the beginning of the dex file, and "index" to refer to a location in the constant pool.

Google: Do they both refer to locations in memory?

Mr. August: They're both numeric memory locations.

Judge: I want to leave you with a question: do you understand what the difference is between you and Dr. Mitchell over this symbolic thing?

Mr. August: I believe I do.

Judge: When we come back, can you explain it using that diagram on the screen? We've heard your view, but can you describe both?

Mr. August: I think I can.

Judge: Great. Okay, time for another 15 minutes.

[Discussion about how much time they need before the end of the day; Google wants 20-25 more minutes on direct]

[Break, a bunch of conferring between the lawyers]

Fri May 11 11:32:04 PDT 2012

And here's the rest of the day, part 3:
[I swear this break was not 15 minutes. No one was ready when the judge came back, and several of the lawyers weren't even in the room yet.]

Google: We're in agreement that the words "HTD Droid Incredible" should be stricken from the transcript.

Judge: Let me check with the court reporter -- can we just do that?

[The reporter explains. Yes, they pretty much can, and they do.]

Judge: [to the jury] We only have about 30 or 35 more minutes to go this week. All set?

David August Testimony Resumes, Google Asking the Questions:

Google: Before the break, the Judge asked a question about the difference between you and Dr. Mitchell for this figure on the screen.

David August: Dr. Mitchell is trying to get the symbolic reference from the string data table into the instruction. There are two possible ways: the first is that somehow, after following a numeric reference to a numeric reference to a symbolic reference, that somehow changes the quality of the original reference.

Judge: I don't understand. Here, you can draw on the screen, like John Madden. [laughter] Show me what you mean.

David August: [He does indeed draw on the screen like John Madden, showing the chain of numeric references that eventually lead to the symbol "fun".]

The second way to bring the symbolic reference into the instruction is to say that the instruction is not just the bytecodes "52 01", but also includes all the data in the tables it references (the field ID table, string ID table, and string data table).

Symbolic references have been in computer programs since before the '104 [patent]; they're all over the place. The symbolic reference in this case exists in the data. To say we're going to treat the numeric reference in this instruction as a symbolic reference, that seems like a stretch to me.

Judge: Okay, so in your opinion, what would actually be a symbolic reference in the instruction?

David August: Ah, so imagine if here in the instruction stream, instead of 01, you actually put "fun" here.

Judge: I don't like that "fun". Let's use "y" or "x".

David August: Okay, so we have "x" here. [explains more what a symbolic reference in the instruction would look like]

Judge: So you're saying that in Android, you never see an "x" or a "y" here in the instruction stream?

David August: Right. I've looked carefully at the Android code, and I can say absolutely for sure that you will never see anything like "x" or "y" in the instruction stream.

In all the documents that describe the format of the instructions, you never see any space to hold a name like "y" or "x".

Google: With respect to the difference, it's that Dr. Mitchell is calling that index 01 in the instruction stream a symbolic reference, correct?

David August: Yes. To get the symbolic reference into the instruction, you have to call that index a symbolic reference.

Google: Why do you think an index is not a symbolic reference?

David August: There's no resolution. There's no question of what 01 refers to; it's a particular memory location. It's not data -- it's just a representation of the position of the 02 and 76 (the data in the field ID table).

It's the actual memory location. 01 is the index that specifies the position within the field ID table where the data is.

Judge: We've all seen that the programs themselves are written with variables like "x" and "y", in the actual Java code, not with memory locations. So where do those get changed to the 01?

David August: That gets done by javac. The programmer wrote something with "y", and javac understands that it needs to create instructions without symbolic references, so it moves the symbols to a separate table and stores their location.

Judge: So, what is javac? What step in the process is it?

David August: It's the Java compiler. [Starts drawing a diagram]

Let's start all the way back at the beginning. Here's a Java program: we have y = "Hello, world!", so we're taking the string "Hello, world!" and storing it in the symbolic reference y.

You run javac, that's the Java compiler, and it'll produce a .class file. This file has both instructions and data. And at this point, we have some instructions... I'm going to use the same numbers as we had before, just for consistency, but really this is Java bytecode, which is different from dex bytecode.

So here, the compiler stores the data y, and stores the numeric reference 01 to tell you where it is.

The next step is another compiler called dex tool. This produces a dex file, which also has instruction and data. Dex tool does a number of things, but it doesn't take the symbolic reference out of the data and put it into the instruction. We'll still find in the instruction in the dex file, it has numeric references, references to other memory locations, and ultimately, at the end of all those references, you have a symbolic reference.

Judge: You have two sets of instructions there. In terms of the patent, is it the dex set or the other set?

David August: It's the dex set.

Judge: So, in your view, you've put the "y" there in the data, but where does the "Hello, world!" go?

David August: Ah, it's also in the data. It's not an instruction, telling the computer what to do; it's just a string. It would actually be in the same string data as "y".

Judge: So it sounds to me like the key point that you make (and believe me, I'm not saying that you're right or wrong, just trying to understand), that in that bottom box, those instructions never contain an "x" or a "y", they always contain a number?

David August: They always contain a number that refers to a memory location. You'll never find a sequence of characters like "x" or "y" there. I think there's no disagreement there.

Judge: So what is the disagreement? Google: So, what is the disagreement? [laughter]

David August: I think they must be imagining some sort of transitive property, where you follow a numeric reference to a numeric reference to a symbolic reference and it somehow makes the whole thing symbolic. Or maybe they're saying that the "instruction" contains all this data, not just the opcode and the operands.

Google: Three issues: first, Dr. Mitchell says that an index is a symbolic reference, correct?

David August: Sometimes.

Google: Is there a disagreement as to whether the instruction stream contains indexes?

David August: No, there's no disagreement. They contain indexes.

Google: Why would you move "y" out of the instruction stream and put it into the string table?

David August: It's about efficiency of executing the instructions. If you have an instruction like "52" (get), you'd like it to be a fixed size. CCCC is four digits -- well, it's hex digits, but close enough -- it's a fixed length. Now if you have a symbolic reference like "y" or, sorry, "fun", it's much more complicated. Now you have to figure out how long it is. You have to figure out when to stop, so you don't run into the other instructions. All of that is much less efficient than just knowing that an instruction that gets data is just two numbers: 52, 01, regardless of the length of the identifier.

Google: There was also a question about whether the dex file was the one we're talking about. Is there another issue with that?

David August: The dex file is what's installed on the device. When you go to the app store, that's what gets delivered. When the program arrives on the device, it goes into dexopt, which processes the file and produces another file, called the odex file, which you've heard of. It's an optimized dex file. It looks very much like the dex file, except it has things like quickened instructions, which you've also heard about.

But its main structure is intact: as far as references are concerned, it has numeric references in the instructions, and the symbolic references are in the data portion. At this point, there's been no execution going on. The owner of the phone hasn't started the application. But at some point, perhaps weeks later, the application will get started, and this odex file will get processed by the virtual machine -- in particular, by the interpreter.

That interpreter is going to go through the instructions as necessary to perform the operations described by the programmer.

Google: Where's the resolve.c functionality on that drawing?

David August: Here, in the interpreter.

Google: Is there a dividing line here between dynamic linking and static linking?

David August: [Pause] Sure. Here, the application arrives on the phone, we do some install-time work. That's a static process, it happens once, it happens before you start the application, before there's any dynamic execution. That produces the odex file, which is just a file that's stored on the device.

Some time later, that file on the device gets executed, and that's where we have the difference between static and dynamic. Now the interpreter executes the program, the user can use it, that's dynamic.

Judge: Okay, we're going to wind up for today. I think we're on track to finish the evidence on Monday morning, and hopefully we'll even have the closings.

[To the jury] For certain the case will be to you by Tuesday, possibly Monday. As before, you'll have to start thinking about days you might want to work in the afternoons.

[More reminders not to do independent research]

We so much appreciate the hard work you're putting into this. You are making a tremendous sacrifice for your country; very few juries have served as long as you.

See you Monday morning.

Judge: [To the lawyers] Now remember, you need to have in writing your agreement on what you want to go to the jury. Whichever you want to jump on that is okay with me.

Let me see how much time we used... [calculates briefly, then stops] I think you both must be keeping track. If you need me to figure it out, it'll take five minutes.

Google: Our legal assistants have been keeping track. I think we can do it.

Judge: Great. See you on Monday.

Fri May 11 12:10:32 PDT 2012

And now you know what paralegals do at trials, among other things.

Update 3: All the trial exhibits are now available as PDFs here. Some are also done as text. Look for the date nearest the day, as they are listed by the date they were entered, which could be a day or so after the date of their use in the courtroom.


  


Day 5 in Patent Phase at Oracle v. Google Trial ~pj - McFadden, Parr, August - Updated 3Xs | 400 comments | Create New Account
Comments belong to whoever posts them. Please notify us of inappropriate comments.
Corrections Thread
Authored by: bugstomper on Friday, May 11 2012 @ 06:21 PM EDT
Please summarize in the Title box error->correction or s/error/correction/ to
make it easy for readers to scan the list to see what errors have already been
reported, and for Mark and PJ to see what needs to be corrected.

[ Reply to This | # ]

Off Topic threads
Authored by: bugstomper on Friday, May 11 2012 @ 06:24 PM EDT
Please stay off topic in these threads. Feel free to spice up your posts with
fancy formatting in HTML Formatted mode, and especially to make your links
delightfully clicky.

[ Reply to This | # ]

News Picks Thread
Authored by: bugstomper on Friday, May 11 2012 @ 06:27 PM EDT
Please type the title of the News Picks in the Title box of your comment to make
it easy for readers to scan the headings. Also please include the link to the
article in the body of your comment, preferably as a clickable link posted in
HTML Formatted mode, for everyone's convenience once the article has scrolled
off the News Picks sidebar.

[ Reply to This | # ]

Going for actual damages is simple math
Authored by: Anonymous on Friday, May 11 2012 @ 06:41 PM EDT
lets say they have a 90% chance of getting $150,000 (though I would expect more
like a 90% chance of getting $50,000). Compare that with a 1% chance of $100
million.

Doing the math,
150,000 * 0.90 = 135,000
100,000,000 * 0.01 = 1,000,000

even a 1% chance of 15 million is still better.

Don't forget, having a 3rd phase increases the billable hours for the lawyers,
so they win no matter what.

[ Reply to This | # ]

Andrew McFadden testimony - zzzzzzzzz
Authored by: Anonymous on Friday, May 11 2012 @ 06:43 PM EDT
Maybe it would have made more sense having the evidence to see at the same time,
but reading that really put me to sleep.

At least Terence Parr's testimony was somewhat interesting. Arrays are probably
much simpler to explain than symbolic referencing though.

[ Reply to This | # ]

Thanks For The Report
Authored by: lnuss on Friday, May 11 2012 @ 06:53 PM EDT
Nice reporting -- thanks, well done!

---
Larry N.

[ Reply to This | # ]

Day 15 at the Oracle v. Google Trial ~pj
Authored by: Anonymous on Friday, May 11 2012 @ 07:02 PM EDT
Christ how is the jury expected to make any sense of all this? I'm an Android
developer with limited knowledge of the dex format and its optimizer and I can
barely make heads or tails out of the level of detail we've dived into here. Why
on earth did the parties not seek a bench trial for this phase? Can the jury
just refuse to return a verdict on the grounds of incomprehensibility?

[ Reply to This | # ]

Fun with fun.... ROTFL
Authored by: SilverWave on Friday, May 11 2012 @ 07:05 PM EDT
Too good.

:-)

---
RMS: The 4 Freedoms
0 run the program for any purpose
1 study the source code and change it
2 make copies and distribute them
3 publish modified versions

[ Reply to This | # ]

Day 15 at the Oracle v. Google Trial ~pj
Authored by: Anonymous on Friday, May 11 2012 @ 07:05 PM EDT
Thanks for this detailed report. The mainstream media's coverage of the patent testimony has been all but useless, but thanks to these details we might get a sense of what is actually going on in that courtroom!

Oracle: So the role of the iget instruction is to obtain actual field data from an object and store it in a Dalvik register, true, sir?

Mr. McFadden: Yes.

Oracle: iget with 01 as the field index, it doesn't store the number 01 in a Dalvik register, right?

Mr. McFadden: Right.

Oracle: It doesn't obtain 2 or 76 and store those in a Dalvik register, does it?

It doesn't obtain the name "byte", does it?

[five or six more questions along these lines, getting more and more excited]

Mr. McFadden: Yes.

Oracle: The actual data is what it stores, right?

Mr. McFadden: Yes.

Oracle: True or false: the Dalvik iget instruction never contains the actual memory location of the actual field it's supposed to get, true?

Mr. McFadden: True.

Oracle: True or false: the va operand is not the memory location of the actual field?

Mr. McFadden: True.

Oracle: The vb and field@CCCC are not the memory location of the actual field?

Mr. McFadden: True.

[By this point the Oracle lawyer looks like he's just triumphantly unveiled the murder weapon. I have no idea what his questions were supposed to mean, though, and the witness sounded like he didn't either. I didn't see the jury's response.]

From the cross exam questions, Oracle's lawyers seem to believe that any indirect reference to the field value is a "symbolic reference" (or maybe they just want to get a jury to believe it.)

Unfortunately for Oracle, it isn't true. A "symbolic reference" is when you have a symbol (a string) that refers to something, and "resolving the reference" means looking up that symbol in some kind of table. (in a compiler, it would be called "the symbol table", for obvious reasons.) A numeric indirection (an index into a different table, or into a data segment) is NOT a symbolic reference. Based on these notes, it sounds very much like if the claim requires a "symbolic reference", Dalvik won't infringe. Oracle's poor lawyers, having to wade through all this technobabble. My heart bleeds for them. /sadface



I skimmed through the '520 patent yesterday, and it just describes a clinit optimization that Java compilers do so the VM can initialize classes faster. I remember this from when I worked on a Java VM ~10 years ago; its sort of a kludge to permit some static initialization of class stuff (instead of having to do it all at runtime). In a sane world this shouldn't be patentable, being (1) entirely software/math and (2) not particularly innovative, or hard to come up with from scratch. Anyway.. why does it use such a kludgy mechanism? Well, Wikipedia says that JDK 1.0 came out in 1996, and this patent wasn't filed until 1998 -- meaning Sun already had working and deployed VMs that were doing something even stupider than this in order to initialize their classes. When they designed this "optimization", it had to fit into their existing system, and not break backward compatibility with existing compiled .class files.

But if you were making a new system from scratch, you would likely try to find a non-kludgy solution to this problem. So I'd say its not surprising that Dalvik doesn't use the same mechanism, because the one from the '520 patent is not particularly great. If you weren't constrained to follow Java's .class format, you could do something simpler and better, which it sounds like Dalvik did.

[ Reply to This | # ]

No reasonable jury & question 3b
Authored by: Anonymous on Friday, May 11 2012 @ 07:08 PM EDT
Question 3b and the jury:

"[Has Oracle proven that Google’s conceded use of the
following was infringing, the only issue being whether such
use was de minimis:]
a. yes, infringing. [The rangeCheck method in TimSort.java
and ComparableTimSort.Java]
b. no, not infringing. [Source code in seven “Impl.java”
files and the one “ACL” file]"

And in the order above: "Here, Google has admitted to
copying the entire files. No reasonable jury could find that
this copying was de minimis."

And yet, the jury answered No to 3b. Would the judge argue
that the jury was unreasonable? Presumably not, or else the
jury is not competent on other questions. How then did the
jury reach this decision if not through de miniumus, given
the phrasing of the question? Which is to say that a
reasonable jury COULD find de-minimus, and that the judge
has erred.

Sounds like grounds for an appeal to me. The jury is
reasonalble, or all verdicts reached by the jury are
suspect.

[ Reply to This | # ]

No reasonable jury?
Authored by: Anonymous on Friday, May 11 2012 @ 07:14 PM EDT
> No reasonable jury could find that the copying of entire computer files was
de minimis.

I disagree. They were a few files out of thousands and not a recognizable
portion of the whole work. Also, I think they were put there by a third party,
though I do not recall the exact details.

In short, I'm not sure why he's considers his jury unreasonable.

[ Reply to This | # ]

Infringer's profits and burden of proof - standard BSF MO?
Authored by: Anonymous on Friday, May 11 2012 @ 07:34 PM EDT
"We're saying once you have proved infringement, we think we have a claim
for infringer's profits, and the burden of proof is on them. The question is not
how much we're entitled to, it's who has the burden." - David Boies

That is SO like BSF in the SCO case. Always trying to escape their own burden
of proof. "They did something! They can't prove that they didn't!"

This act is getting old.

MSS2

[ Reply to This | # ]

Day 15 at the Oracle v. Google Trial ~pj
Authored by: Anonymous on Friday, May 11 2012 @ 07:35 PM EDT
I know how hard it is to teach a basic understanding of the concepts involved in
programming. I know the kind of cray toe curling misconceptions students are
capable of coming up with. And these are people who have an interest and have
decided to study the subject.

I'm now trying to imagine taking a bunch of completely random people off the
street who probably have no interest in or aptitude for the subject and getting
them to understand the difference between static and dynamic linking.

I'm trying to imagine teaching them about this under the handicap of not being
allod the freedom to explain properly but being constrained to only answer
yes/no questions.

I'm trying to imagine doing it while not being able to ask questions to test
their understanding, or have them ask me questions about the things they don't
understand.

They get no assignments to make them think. They don't get assessed or tested to
see if they are learned.

I can't imagine an educationally worse process. I shudder to think what is most
likely going on in their brains at the end of it all. And millions of dollars
hang off this?

[ Reply to This | # ]

Oracle's definition of "dynamic" is flawed
Authored by: dcs on Friday, May 11 2012 @ 08:03 PM EDT
Oracle tries to show that, because dexopt happens when the
handset is turned on ("running", in Oracle's parlay), what
it does is "dynamic".

However, by Oracle's definition of "runtime", nothing is
static, since programs only run when the computer is
running.

"Runtime" means "when the program is executing".
"Dynamic"
is what happens to the program at runtime -- when it is
executing. "Static" is what happens to the program before
runtime -- before it gets executed.

This is the definition of static and dynamic, and Oracle is
portraying them as something else, something that doesn't
even make sense.


---
Daniel C. Sobral

[ Reply to This | # ]

David August Testimony - Devastating to Oracle's case.
Authored by: SilverWave on Friday, May 11 2012 @ 08:33 PM EDT
Yep Devastating.

---
RMS: The 4 Freedoms
0 run the program for any purpose
1 study the source code and change it
2 make copies and distribute them
3 publish modified versions

[ Reply to This | # ]

Da Judge
Authored by: rsteinmetz70112 on Friday, May 11 2012 @ 09:22 PM EDT
I have recently gotten the impression that the Judge is much more than an
impartial referee in this case. He may have an agenda of his own.

It is difficult to tell how good Oracles patent case was, but Google's seems
very persuasive. At best it's a he said he said case, and the jury has already
mostly sided with Google on copyright.

The jury has demonstrated they are not convinced by Oracles copyright evidence.
They couldn't reach a verdict on fair use but at least some on the jury felt
Google's actions were fair use. That does not bode well for damages.

Is it possible he is setting Oracle up to win a small award in the damages phase
followed by his ruling against Oracle on SSO. Setting up a no win appeal
Oracle?

If Oracle were to win on the patent appeal and get an injunction exactly what
would they be enjoined against? Who would decide if Google had coded around
these patents?

Seems more and more like the Fat Lady is a long way off.

---
Rsteinmetz - IANAL therefore my opinions are illegal.

"I could be wrong now, but I don't think so."
Randy Newman - The Title Theme from Monk

[ Reply to This | # ]

Stored pgm - Oracle v. Google Trial ~pj - McFadden, Parr, August
Authored by: Anonymous on Friday, May 11 2012 @ 09:25 PM EDT
Now I understand. McFadden is describing a stored program machine,
calculated Go To.

Wait, I thought they banned that because it is risky.

When was it invented? 1940 something?

[ Reply to This | # ]

Mappers vs. Packers, redux
Authored by: Anonymous on Friday, May 11 2012 @ 09:47 PM EDT
Mappers vs. Packers, redux:



Judge: Is there a reason the numbering of the opcodes skips 1?

Mr. Parr: Good question. It's basically the address, and some instructions take more space than the others. For example, the "dup" instruction takes one byte, so it's at address 3 and the next is at address 4. Imagine going down the street, some people have a big fancy house and it takes up a lot of space, some people have small houses. The more information you have to pack into the instruction, the more space it takes.

Judge: I still don't understand why there's no address 1.

Mr. Parr: The iconst_4 instruction occupies both address 0 and address 1.

Judge: Ah, okay.

Dr. Parr is a programmer, and used to "Mapper" style thinking. He gives an explanation that "some instructions take more space than others", but it probably doesn't even occur to him to state explicitly that "this instruction takes two bytes", because to him it is an unnecessary detail, that should be obvious anyway from the context.

Judge Alsup on the other hand, is trained to carefully analyze facts and draw inferences, but to not assume anything. He's not a domain expert and if he just went ahead assuming things, he would probably get them wrong. So he asks a clarifying question. To Dr. Parr's credit, he immediately understands what detail he skipped over and states it clearly. I guess that's because he's also a professor: he's good at noticing which concepts the student already understands and linking new things to those. And he also gives feedback to his student ("good question").



I love reading exchanges like this, because it shows how intent Judge Alsup is on understanding the tech as well as he can in such a short amount of time (or at least well enough to be able to make legally-sound rulings about it). I could follow along with McFadden and Parr's testimony easily enough, because I've been programming for over 20 years and know a lot about compilers and VMs. To a non-programmer this stuff must be nearly bewildering.

I was thinking about this earlier today and I realized that from a certain point of view, Judge Alsup has one of the most interesting jobs in the world: most of his cases are probably relatively mundane, but occasionally he gets something crazy like this one, and then he gets real subject-matter experts coming into his courtroom and giving him a crash course in some complex field like programming or biology or whatever. So he gets this little "peek behind the curtain", and then when the case is done he can move on to something else. :P


P.S. Big thanks to our courtroom reporters! You guys and gals are doing a great service for the rest of us.

[ Reply to This | # ]

Day 15 at the Oracle v. Google Trial ~pj - McFadden, Parr, August
Authored by: Anonymous on Friday, May 11 2012 @ 10:02 PM EDT
I wonder if anyone there at the trial who wasn't a computer scientist could even
begin to know what was being talked about in regards to the patents. Without a
background in computer science or significant programming experience, I don't
see how anyone could see the testimonies as anything other than just experts
disagreeing with each other, with gobbledygook spicing up the discussion.

The main contention has been Oracle's definition of the words used in the
patents. I don't see how the jury will be able to come to an informed decision,
if the exact definition of the words are not agreed upon. This makes me wonder,
if a patent can be challenged at the patent office to clarify terminologies
being used. Forcing them to add specific definition of words to the patent to
increase specificity.

[ Reply to This | # ]

Day 15 at the Oracle v. Google Trial ~pj - McFadden, Parr, August
Authored by: Rubberman on Friday, May 11 2012 @ 10:02 PM EDT
I have 30 years experience as a software engineer, with a
major software patent to my name (as exclusive inventor)
that covers software that runs most of the semiconductor
fabs in the world today. The testimonies today were just
fabulous! As I have said in other postings during this
trial, this is the best entertainment I've had in a long
time! Thanks PJ for the efforts you and your
reporters/observers have been putting in at this trial! It
is an incredibly important one, and I think that if Oracle
took just a few seconds to really think about the possible
repercussions that a finding in their favor would mean,
they'd drop their case/claims as quickly as they could!

[ Reply to This | # ]

Tweets from the courtroom
Authored by: feldegast on Friday, May 11 2012 @ 10:03 PM EDT
https://twitter.com/#!/Feldegast
Raw feed: https://twitter. com/#!/Feldegast/oracal-vs- google-trial

---
IANAL
My posts are ©2004-2012 and released under the Creative Commons License Attribution-Noncommercial 2.0
P.J. has permission for commercial use.

[ Reply to This | # ]

This software patents nonsense has to stop, it's killing the industry
Authored by: Anonymous on Friday, May 11 2012 @ 11:08 PM EDT
Regardless of which legal team wins the patent phase of this trial, everyone
else loses. That includes all the technical people at both Oracle and Google
too, they both lose bigtime regardless of the verdict, because this very high
profile trial is validating the concept of software patents in the US and
killing the industry of which they are a part.

You might as well slit the throats of all software developers if this continues,
at least those in the US. It's no different to all chefs becoming liable to
culinary patent infringement every time they mix ingredients in one combination
or another, or all writers becoming liable for grammatical patent infringement
each time they use a particular combination of words. It's just madness.

It has been said a million times already that the only beneficiaries of this
madness are the lawyers, and that is certainly true. But why aren't all the
computing megacorps fighting tooth and nail against software patents, with the
possible exception of Oracle on grounds of greed-driven insanity?

I really don't get this situation. The software industry here seems to have a
deathwish.

Why?

[ Reply to This | # ]

Day 15 at the Oracle v. Google Trial ~pj - McFadden, Parr, August
Authored by: xtifr on Friday, May 11 2012 @ 11:58 PM EDT
A lot of people reading this seem fairly confused by some of the technical talk.
Let me remind everyone that there were diagrams and charts available to the
judge and jury that we don't get to see. As an experienced programmer, I was
able to figure out approximately what must have been on the charts in most
cases, just from hearing what was said. If the charts were like what I imagine,
then I don't think the judge and jury were as confused as many readers here
are.

I can't be sure, because I already understand the topics being discussed, so I
may be overestimating how clear the charts would make things. But the fact that
the judge was able to ask some very insightful questions makes me fairly
confident that the material was actually reasonably clear.

---
Do not meddle in the affairs of Wizards, for it makes them soggy and hard to
light.

[ Reply to This | # ]

To what extent, if at all...
Authored by: Anonymous on Saturday, May 12 2012 @ 12:17 AM EDT
I find it amusing that the lawyers aren't supposed to lead the witnesses, but there's a sort of "wrapper" they can apply to make it all alright.
Google: Tell me that we're pure and innocent as the driven snow

Oracle: Objection!

Judge: You have to say "Simon says"

Google: Simon says tell me that we're pure and innocent as the driven snow

Witness: But of course!

[ Reply to This | # ]

Reasonable jury
Authored by: Anonymous on Saturday, May 12 2012 @ 12:47 AM EDT
"No reasonable jury could find that this copying was de minimis."

Balderdash. The judge is making up law. Of course a "reasonable"
jury could find these few files to be de-minimus. If anything, no reasonable
jury could find to the contrary.

You are wrong PJ, there is no evidence at all that this judge is anything but a
word-game playing moron just like all other judges and lawyers.

[ Reply to This | # ]

It's like scorekeeping in baseball.
Authored by: Anonymous on Saturday, May 12 2012 @ 02:15 AM EDT
Let me see how much time we used... [calculates briefly, then stops] I think you both must be keeping track. If you need me to figure it out, it'll take five minutes.

Google: Our legal assistants have been keeping track. I think we can do it.

Judge: Great. See you on Monday.

I'm not sure I understand this bit, so maybe someone can correct me if I'm way off.

It sounds to me like the Judge was asking them "do you need the real number, which it will take me 5 minutes or so to calculate? Or are you OK just relying on your own estimates for whatever planning you need to do between now and Monday?" and the lawyers answered "we're fine going by our own estimates".

Maybe this means the paralegals exchange counts, and unless they are wildly different or something, each side just assumes the real numbers are in that ballpark. (Just like baseball scorekeepers at community baseball games -- there's one from each team, usually the spouse of one of the players, and they compare scores every inning or two, to make sure there's no significant discrepancies).

Or maybe they don't share with each other, and each team just relies on their own estimate, until the Judge "re-syncs" them by giving them his own counts.

...I feel almost guilty that I find a detail like this interesting, when there's so much important stuff going on in the case itself! But I admit that from a comfortable outsider's viewpoint, watching this whole process occur is fascinating, and not just for the usual "train-wreck in slow motion" reasons (but that too).

[ Reply to This | # ]

A simple explanation of the patents by I-Programmer
Authored by: Anonymous on Saturday, May 12 2012 @ 02:57 AM EDT

I-Programmer Reads the Patents

Comment on RE38104: "This is a patent that bears the name of James Gosling, the father of Java, so I would rather not criticize it too much - but I have no choice."

[ Reply to This | # ]

Day 15 at the Oracle v. Google Trial ~pj - McFadden, Parr, August
Authored by: Anonymous on Saturday, May 12 2012 @ 04:58 AM EDT
I like this bit:
Judge {to Oracle}: ...I'll explain to the jury that you've got no evidence...
Nothing new for BS&F then...
...If you can prove real damages on that, you're a great lawyer. [Smiles at Boies]
Lawyer's not the word I would use (but it does start and end with the same letters)...

[ Reply to This | # ]

  • why is it... - Authored by: BJ on Saturday, May 12 2012 @ 03:15 PM EDT
Actual damages
Authored by: Ian Al on Saturday, May 12 2012 @ 05:07 AM EDT
PJ wrote (and I selectively read in case it does not support my prejudice):
...test files don't normally ship, and users certainly don't use them... Oracle has opted to go for actual damages, not statutory, despite the judge's warning that they are making a mistake... so there will be a phase three.
Then, there was what the judge ordered (I'm not daft enough to chop that up!):
Dr. Cockburn has not adequately valued that [allegedly copied] code in his report and cannot do so at trial. This order holds that the jury will be instructed that if Google is found not liable for infringing the selection, arrangement, and structure of the API packages, then Dr. Cockburn’s copyright damages analysis is inapplicable.
Analysing the term 'actual damages' using the English language (I know, I know! What has that got to do with legal language!) that could mean damages actually incurred by Oracle because of Google's copyright infringement.

I look first at the directly copied test files put into the Android current version repository by the European code company and against the terms of their contract with Google. Google only found that out when Oracle pointed it out a couple of year's ago. Google took it out of the current repository a year ago. Google would not have asked developers to use test files that they did not know had shipped. As PJ says, they never got to the production phones.

So the files were on countless (as in, we have no way of knowing how many) developers' machines for three years and were never used. How much actual damage was done to Oracle for files that were not known about by developers or Google and were never used?

How about rangeCheck? Supposing Google had to get a high school coder to write one from scratch? How much would that have cost Google? Say, $150? What about getting whiz coder Josh Bloch to do it? $1,500? How much would Google have been prepared to pay Oracle for those 9 lines? What about the ninth line that just had '}' in it?

Perhaps I am looking in the wrong direction. Perhaps it was all about the value to Google of using the code. What does it do? If a programmer makes a total Cockburn of his program [his, because girlie programmers have more sense] getting the range of an array wrong and it is picked up by rangeCheck, would the incompetent programmer have thought to program a suitable response to the returned error message? Probably not. So, what would the problem be of leaving it out, altogether. Nothing in those circumstances. Supposing he got the range wrong, but programmed in a recovery in response to the error message? Who knows?

But wait, what did Mitchell say was important? He said that the rangeCheck function was used 2600 times (whatever, I can't find the quote) in the Dalvik startup phase. If rangeCheck had found an error in the startup phase it would have been a major failure in the Dalvik platform code and not the apps. Even if rangeCheck had not been used during Dalvik coding, the error had to be sorted before Android ever shipped to developers, let alone 'phones.

So, the use highlighted by Mitchell was examples of code wasting time in the Dalvik startup phase because any such errors had to be resolved during Dalvik development. How much actual damage was done to Oracle, because their code was substantially slowing down Dalvik startup? Perhaps it was putting the Java ecosystem at risk of ridicule? No, that cannot be. Oracle explain to us that Android is fragmenting the ecosystem. In fact, they demand that the ecosystem is fragmented even more by making Java APIs unavailable to Google.

For completeness, lets consider what Mitchell studiously avoids; the apps. The whole point of the APIs and the patents is the apps written in Java language. If an app has a range check error, it is likely to crash. What is the actual damage to Oracle if an Android app crashes?

The judge will tell the jury that Dr. Cockburn’s copyright damages analysis is inapplicable. I'm assuming that he will have ruled on the SSO by the time of the damages trial phase and that what he has signalled will come to pass. So, Cockburn's damages report is out and Dr. Kearl's report is based on the whole of Java, or at least, the whole of the value of the APIs.

So, the lucky jury get to go to the damages phase three. What actual damage to Oracle will they find for Google using nine lines of code that does nothing in Android or development and test files that, just do nothing but sit there, unseen until Larry wants money? You know, I think I'm beginning to see Judge Alsup's point! I am not unhappy that Jacobs does not. Brain the size of the planet, and he has to spout so much Oracle drivel. I hope he gets better, soon. This is not good for him.

---
Regards
Ian Al
Software Patents: It's the disclosed functions in the patent, stupid!

[ Reply to This | # ]

100% ON topic IMHO
Authored by: Anonymous on Saturday, May 12 2012 @ 06:19 AM EDT
Thank you for this wonderful and crystal clear explanation - it should have been
placed as a new topic instead of being buried in a thread :-)

Hopefully the Google folks will find and read it anyway!

Bernd

[ Reply to This | # ]

  • 100% ON topic IMHO - Authored by: Anonymous on Saturday, May 12 2012 @ 06:37 AM EDT
    • Thanks - Authored by: Anonymous on Saturday, May 12 2012 @ 10:51 AM EDT
Google's waived invalidity defense & Bilski?
Authored by: SLi on Saturday, May 12 2012 @ 06:22 AM EDT

Have I understood correctly that Google agreed to not contest the validity of the patents? So, they have even waived the argument that they, as software patents, are invalid under Bilski, because they are directed to an abstract idea?

Why would Google do this?

[ Reply to This | # ]

Hoping against all the odds...
Authored by: Anonymous on Saturday, May 12 2012 @ 06:53 AM EDT
that the Judge susses out that all these patents are basically algorithms and
thus the patents themselves are not valid as the subject matter is not
patentable being merely mathematics...

[ Reply to This | # ]

I exchanged some memory for speed
Authored by: Anonymous on Saturday, May 12 2012 @ 10:11 AM EDT
This reminds me of my 6502 days.
Swapping zero page memory
/Arthur

[ Reply to This | # ]

Day 15 at the Oracle v. Google Trial ~pj - McFadden, Parr, August
Authored by: Anonymous on Saturday, May 12 2012 @ 11:42 AM EDT
*cough*taking a leak*cough* a break?

As a more tech person i'm not calling for some fancy foo/software, but please,
that problem is really solved since ages.
No matter if a real chess clock can be stopped or not, two stop watches or what
ever will do.
Or maybe yes, a special clock, but which should be a requisite in every
courtroom, like the hammer.

[ Reply to This | # ]

Day 15: The jury luvs Gool.
Authored by: webster on Saturday, May 12 2012 @ 12:44 PM EDT


1. It must be depressing to the Oracle team to realize that the jury is going the extra mile for Google. Even on the admitted copying the jury found for Google by stretching with the "de minimis" concept. Oracle's burden of proof is high for this jury. There is at least one juror that will hang for Google. Oracle has also annoyed the judge more than Google has. [Does anyone have a score of tantrums with a vehemence scale and presence of jury breakdown?]

2. Nevertheless, the judge has taken the sacrosanct jury verdict away from Google on the admitted copying point. This is risky business for the judge. Although that peculiar judge is gone from the Federal Circuit Court of Appeals, trifling with jury verdicts pricks all their ears. Remember Kimball and SCO I.

3. Why is the jury trial so sacred? It is a safeguard against a totalitarian state. It takes the decision away from the branches of the government and puts it directly on citizens. As counsel is wont to say to a jury:

___________"It is a decision so important that it is not left to a president, governor or mayor, or a majority of a house, senate or city council. It is a decision so important that it is not determined by a plurality, majority, or super-majority. It has to be unanimous!"________
So with this love for the jury, the commons has to put up with some irrationality. Or as is repeated here every few months, with sympathy over reason. The jury will try and do what they want to be fair despite what the facts, law and judge might indicate. Cf. State v Simpson, 1995.

4. Of course the jury does not know the law so they may produce some unintended consequences. If they decide to throw Oracle a patent bone, they may cause far more damage than they understand. However, at least one juror hung them for "fair use" despite finding API infringement. A reasonable patent defense should produce at least a hung jury. The jury may have hung for infringement, 1a, if they didn't have the 1b alternative.

5. This day continues to illustrate the judicial absurdity of trying patents before laymen. It is experts at dawn with an array of seasoned programmers opining on software code. They may as well be opining on complex math formulas for all the jury or any lay person can understand. The Judge hired Dr. Kearl on damages. Why doesn't the judge insist on a neutral patent expert or panel to present to the jury instead of the de riguer contradictory dueling party banjos? The jury should say, "If biased, knowledgeable experts won't agree, why and how should we? We need an unbiased analysis and opinion."

6. Just being in court arguing about software patents in concepts and terms the jury can't possible understand gives the patents a dignity they don't deserve. The party is not allowed to criticize the Patent Office. The patents are presumed valid. The jury has been properly screened so they should be unbiased, and definitely ignorant, about software patents. They can be incredibly destructive here even in trying to help Google.

Caution to all observers and Disclaimer. Most that read, report and comment on Groklaw have a bias against software patents. They are not limited to just what the jury hears, and the jury's deliberations. The jury has an entirely unique perspective. The more experience one has with trials, the less one can predict because so much can and has happened. In so far as the above notes a sympathy for one party, it must not be considered as a prediction. So much for the small print.


~webster~



[ Reply to This | # ]

Tragedy at the USPTO
Authored by: Anonymous on Saturday, May 12 2012 @ 01:14 PM EDT

That's the tragedy of the USPTO, that they seem to have no engineers who are able to spot a goofy patent application when they see one.
I think the tragedy may lie deeper then quite potentially the patent examiners.

Not being part of the USPTO, I can only speak to what occurs outside the USPTO. And what occurs outside the USPTO is - quite simply:

    The Legal Profession keeps telling the engineers that they are not qualified to interpret a patent's claims!
We keep getting that drilled into us over and over again. That makes absolutely no sense to us because:
    A: We're the ones who are supposed to be responsible for the invention in the first place that the patent was filed against.
    B: We're the ones who are supposed to be able to build the invention out of reading the patent filing.
    C: We're the ones who are held responsible for trebble damages if we are aware of the patent.
Taking C into context.... I'm seriously not qualified to understand the text that I read but I'm qualified enough to face trebble damages?

Let's extrapolate that to - maybe - what might be happening at the USPTO.

    Patent examiner reviews the patent filing with hands tied. Remember, they have limitations placed on them such as not being able to reference the internet.
    Patent examiner denies patent filing on various grounds including obviousness.
    Path 1: Lawyer obfuscates wording of patent till examiner no longer recognizes it and stamps valid - by default (remember, I'm hypothesizing) if the examiner can't understand the invention, the invention must be really, really advanced.
    Path 2: The Lawyer appeals to the USPTO appeals board - quite possibly populated with members of the Legal profession with no Engineers. The appeals board overrules the patent examiner.
So... here's the magic question:
    If the patent examiner was an advanced engineer would s/he still be constrained on what s/he could effectively do the same way the rest of us are? By the Legal Profession telling the individual they are not qualified to interpret/understand the patent claims?
Perhaps the Tragedy lies much, much deeper then the USPTO lacking engineers.

Perhaps the real tragedy lies in the Thomas Jefferson's no longer being the gate keepers of what is allowed to be patented.

RAS

[ Reply to This | # ]

WHEN are symbolic references resolved into addresses in JVM and Dalvik?
Authored by: Anonymous on Saturday, May 12 2012 @ 07:02 PM EDT
Clearly, te difference between symbolic and non-symbolic references Is
when te symbolic references, like employee_ssn translated into an
address.

I don't think I have seen a clear explanation of when this appens in the two
systems. A real missed opportunity when the judge asked te witness to
illustrate te differene between his take and Dr. Mitchel' (for Oracle).

[ Reply to This | # ]

Restitution, Unjust Enrichment, and Disgorgement of Profits
Authored by: Anonymous on Saturday, May 12 2012 @ 11:20 PM EDT
So, I'm not sure if I can really do this topic justice, but I wanted to point
out that the availability of infringer's profits in a copyright action is quite
reasonable. To keep things simple, I'm not going to go anywhere near the facts
of this case, though.

The basic idea is difficult to disagree with: that bad actors should not be
allowed to profit from their bad actions, whether or not their profits are
directly at the expense of the victim of those bad actions. This is the
morality (equity) underlying the remedy of unjust enrichment, part of the law of
restitution.

A general example (not copyright related) would be if I owe you a duty (of
confidence, say) and I breach this confidence (sharing the confidential
information) because it is profitable for me to do so. Even if you would not
have been able to profit from sharing this information (if you intended to and
could have done so, then you would be seeking lost profits), since I breached a
duty and made a profit, I am made to pay over profits flowing from the breach in
restitution of my unjust enrichment (not necessarily at your financial
expense).

Here's a slightly more detailed example of why this kind of remedy is available
for copyright infringement:

Let's say that I have written and published a book in English, I have no
intention of translating this book into Spanish or allowing someone else to do
so. My profit margin per copy sold is $5. You come along and decide that the
book would sell well in Spanish, so you translate and publish my book without
getting my permission, and you sell a millions copies. Your profit margin is $7
per copy. I sue you for copyright infringement, seeking actual damages and
disgorgement of profits. You would be able to argue that my actual provable
damages are $0, because I was not offering a Spanish translation, and so I have
not lost any sales of my English book - for the sake of simplicity, we can
presume that no one who bought the book in Spanish would have bought the book in
English - so we are selling our books in entirely different markets.

You have profited millions of dollars from the sale of your translation of my
book (much more than what's available in statutory damages), you have infringed
my copyright, and yet you have caused me no actual damages. If I was unable to
also claim disgorgement of your profits, you would (happily) pay me the small
amount of statutory damages and keep your millions in profits. In order to
prevent copyright infringement in cases like this (and I'm sure they would be
common), the law allows me to also claim your profits.

A further example, dealing with the issue of double recovery, where we are
selling in the same market:

Let's say that now you don't translate my book into Spanish, but simply sell
your own unauthorized edition of my book. Your profit margin is still $7, mine
is still $5, and you still sell a million copies. I would be able to argue that
every copy you sold was one that I didn't, so at my $5 profit margin I could
prove $5 million in actual damages. If I was not allowed to also claim
disgorgement of your profits, you'd still be able to make a $2 million profit by
infringing. Here is where the bar on double recovery comes into play: you have
made a $7 million profit, and I have proven $5 million in damages. If I was to
get all of your profit plus my losses that would be $12 million, which would
also be an unjust and excessive recovery. So instead I only get that portion of
your profits that were not included in my losses, and so I get $7 million in
total.

Hopefully this now all makes (some) sense.

Obviously the case at hand is a bit more complicated in that Oracle is going to
have to show that some of Google's profits flow from the use of those nine lines
of code. I believe that this is the part the the judge is not going to allow
Oracle to introduce evidence on, since it was left out of their first two
attempts at a damages report.

I am surprised that the jury will be determining the amount, though. My
understanding was that even though it's in the statute, it's still an equitable
remedy (as all restitution is, IIRC) and so should be determined by the judge.
I am by no means an expert in US law, however, so maybe the fact that it's in
the statute somehow transforms it to a legal remedy, or maybe equitable
statutory remedies are their own kind of thing.

[ Reply to This | # ]

The order makes no sense
Authored by: BitOBear on Monday, May 14 2012 @ 06:48 AM EDT
The jury was ordered to consider the entire SSO of the entire API (e.g. the
"166 APIs") where "each API" had multiple files.

Seven files out of thousands is de minimus (spelling) by definition. The jury
was ordered to consider the "wholeness of the whole" and the judge
just said that these tiny parts couldn't de minimus because of their
"wholeness of the parts". [sarcasm quotes mine.]

Mandatory car analogy: "vandal" takes the four valve stem caps off the
tires of a car. Jury is asked "did vandal steal a significant fraction of
the car". Jury says no. Judge says jury is wrong, the car was largely
stolen and no reasonable jury could find that the "theft" was minimal.
Judge is wrong.

====

Next, the act of decompiling the purely functional object code and ending up
with "identical" source demonstrates that the source elements copied
were -exactly- and -completely- functional. They were, after all, the
disgorgement of the functional element back into the form of source code by the
decompiler.

So if the jury was wrong about the files being copied, then any ruling that the
files have any "non-functional" a.k.a. "expressive" value is
-impossible- by definition. Anything "expressive" would have been
purged when the code was vacuumed up by the compiler and turned into executable
object code. There is no such thing more functional in computer science than a
valid object file.

So Oracle, in proving the original source and the decompiled source
"identical" proved in turn that it was wholly devoid of all
expressive, non-functional elements.

So the parts of the files copied by this method were wholly demonstrated to be
outside the scope of copyright law as -proven- by Oracle.

[ Reply to This | # ]

Groklaw © Copyright 2003-2013 Pamela Jones.
All trademarks and copyrights on this page are owned by their respective owners.
Comments are owned by the individual posters.

PJ's articles are licensed under a Creative Commons License. ( Details )