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 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.”

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.

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.

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.

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.

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]

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

[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

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.