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
Reports from the Oracle v. Google Trial - Day 6, Patent Phase - Drs. August and Mitchell , ~pj - Updated 5Xs
Monday, May 14 2012 @ 01:06 PM EDT

The judge has ruled on the weird Oracle motion [PDF] to delay the damages phase of the trial to get a new jury. It's a no from Judge William Alsup, also calling their position on the 9 lines of code and the test files and damages "super extreme". They'll have to present it to *this* jury. There's no way the law should allow a disgorgement theory over millions or billions of dollars for nine lines of code, the judge tells them, our man in the courtroom tells us. The 37 APIs will not be part of phase three, "because liability has not been proven on that". So that's that. Google's motion for summary judgment on copyright damages [PDF] is also denied. It's on to the damages phase after closing statements by tomorrow, with this jury. Meanwhile, Google expert Dr. David August, who testified on Friday, is back on the witness stand.

Jump To Comments

[Update 1, Update 2,
Update 3, Update 4, Update 5]

Here's the first report on the discussions prior to the jury entering the room:
5/14/12, 7:31am

Stipulation to try willfulness in phase 2- seems ok with judge, but wants to make sure he understands the impact.

Some dispute as to what evidence would be presented for this. Google wants an instruction that willfulness is to be measured before the lawsuit is filed, doesn’t want post-litigation conduct involved. Oracle wants to argue that Google has been willful because Rubin testified that no changes were made after Oracle gave notice.

Jacobs: [Seagate?] says that ordinarily pre-litigation conduct is what is necessary.

Judge Alsup: So why don’t we do what is ordinary?

Jacobs: Because this is extraordinary. [chuckles…]

Judge Alsup: The Lindholm email doesn’t say “my god” look at this ‘520 patent, my god look at this ‘104 patent. We’ve got to look at these… I don’t know the answer to this, a moving target. Limit the instruction to pre-litigation conduct and will Google be allowed to put in evidence about the re-examinations to show non-willfulness? Is there such a thing as willful indirect infringement or is it only direct infringement?

Google: Only for direct infringement.

Willfulness will go to the jury in phase 2! Judge to decide the pre-litigation and re-examination issues.

[This all goes back to the Lindholm email. Oracle wants to bring it back to demonstrate Google’s willfulness. Aren’t we all sick of this by now?]

Judge has prepared new jury instructions, special verdict form.

Judge Alsup: Leaves a false impression if Oracle argues that Google didn’t do anything all this time after the lawsuit was filed because the patents were under PTO review.

Oracle: But validity isn’t at issue here. Also there was long time between the lawsuit and when the re-examination was filed.

Judge Alsup: This is going to be a mess if we get into post-complaint stuff. No post-complaint stuff. Jury instruction will say not to speculate about events after the filing of the complaint and willfulness is up to the day of the complaint. Wants briefs on whether willfulness applies to direct/indirect.

Judge isn’t buying the idea that Google just sat on the issue; they went to the PTO and were pretty successful in these actions.

Some quibbling over definitions in the instructions. Can a symbolic reference be a number? Oracle also asking to redefine dynamic/static.

Jacobs: Dynamically doesn’t mean the same thing as run-time. We’re misunderstanding the basic rules of set theory.

[PJ: All the techies here at Groklaw call this statement an absolute howler. Here's a comment and some more that will explain why they think Mr. Jacobs is so, so far off. It's very hard for the techies here, who actually do write this kind of code and know exactly how it works, to listen to the lawyers say things like this, without wincing. They do allow that perhaps he was misquoted. We'll wait for the court transcripts to be certain.]

Judge Alsup: Re Google’s proposed changes in jury instructions: Didn’t I reject most of your augments at the charging conference?

The willful blindness instruction. If it does go in, Google wants more context, should require active acts and not just passive ones to avoid learning of patents. The decision not to take an action is not an active act.

Judge Alsup:: You’ve seen in the movies a hundred times when a guy raises his hand and says “Stop. I don’t want to know that. Don’t tell me that.” You can argue the facts to the jury.

Google: Shouldn’t have to argue it because the facts don’t support it.

Instructions 19-20: Google doesn’t want “mobile service providers” involved. Oracle says that Rubin testified that phones were sold through Verizon.

All of these motions are denied.

If liability is established for patents, we’ll have a damages phase on patents. In any event, there will be a damages phase on the decompiled code and rangeChceck. No damages phase on the main copyright issues because liability not established. “The court totally rejects Oracle’s argument, and I don’t even understand the argument. You get a favorable verdict on question 3 and the time to deliver on damages is phase 3.” Nothing else goes in phase 3 because no liability has been shown. We’re not going to get into the 39 packages because liability has not been proven on that.

If the day ever comes when that is established, we’ll have a new trial on that issue.

Judge Alsup: Motion for summary judgement: No way the law should allow a disgorgement theory over millions or billions of dollars for nine lines. Mr. Jacobs wants his day in court and he can have that. “Super extreme, hyper extreme proposition.”

Update: And a second report:

Subject to a condition, parties have agreed to make indirect infringement follow automatically from a finding of direct infringement (inducement or contributory). This would streamline things for the jury. Condition is that both parties need to reconfigure closings. Both would need to close by tomorrow. That’s what they'll do. Indirect infringement is out of the instructions and jury form. If the jury finds direct infringement, the court shall enter a judgment for both direct and indirect infringement.

So if the jury finds infringement, Google would be liable for the handsets? Some quibbling over the exact intent, but they are basically in agreement. Oracle asks for a sidebar.

Judge Alsup: Is this something the witness can’t hear or something the public can’t hear? [jury is not in the room] No sidebar happens.

Would be binding on Google but not on Motorola or anyone else because they aren’t present.

Caleb Garling of Wired also tweeted this tidbit:
Dr August (Google's expert) rebuking Dr Mitchell (Oracle's). Mitchell is sitting attentively, listening, but betraying no emotion
The judge believed that he had to overrule the jury on the test files, because Mitchell said they were very important (--so important Google didn't even know they were there until Oracle told them since it wasn't Google who put them there, m'lords?), and he wrote in his order that no one contradicted that testimony, and that's why he had to rule as a matter of law that the evidence from Dr. Mitchell established the point. As we see here, Google is not taking any chances that it could happen again.

I don't see why a jury can't decide they don't believe a word that man said, if that is their decision. The jury instructions say that is their job, to evaluate credibility. If they didn't believe Dr. Mitchell, as I didn't, why can't they so decide? I know. Logic. Mark tells me I'm off base on this. For the jury to reach a different conclusion, he explained to me, there would have to be evidence that Dr. Mitchell's statement was unfounded (Google's burden of proof) or that there was contradictory evidence (Google's burden of proof). The jury can't simply decide that Mitchell's testimony was not credible absent some challenge or contradictory evidence. To which I say, why not? If on other issues, where there was evidence, they listened and decided nothing he said was credible, why shouldn't that be their job and their right? Sometimes the law and logic diverge, as you may have noticed.

: )

It looks like the patent phase is coming down to a battle of the experts, with Oracle's Dr. Mitchell claiming one thing and Google's Dr. August the opposite regarding patents. Ginny LaRoe tweets:

Google expert: "Android doesn't contain symbolic references of any kind ... so there's no infringement."
The argument has to do with whether Dalvik does what the Oracle patents describes, and on Friday, Dr. August, another expert Terrence Parr, and Andrew McFadden, who wrote Dalvik, were very clear that it does not.

Both Google and Oracle have rested. We have heard all the evidence for the patent phase. Closing arguments in the morning. The jury has gone home for the day.

Update 2: Zach has a fuller report now, taking us through to the point where Google rests but before Oracle's rebuttal:

OK here's the next part of the notes, covering Dr. August's testimony through Google resting its case. I'll have notes from Oracle's furthering questioning of Dr. Mitchell later this afternoon.

8:09 AM – jury enters

Judge Alsup: welcome back. Hope you all enjoyed Mother’s Day weekend. Plan to finish evidence today, not sure whether we’ll get to closing arguments.

Direct Examination of Dr. David August Continues from Friday

Google: Looking at the claim construction for a symbolic reference: “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” With this, do dexopt and resolve.c infringe the ‘104 patent?

August: No. They do not operate on instructions that contain symbolic references.

Pulls up Mr. Andrew McFadden’s chart [ed. we can’t see it]. Asks Dr. August to walk through the dex file instructions and explain what is a symbolic and what is numeric reference.

August: [Fumbling to get a pointer stick and arrange the flip chart.] Here we have an instruction 52 and a single operand 01. What is that operand 01? Let’s apply the court’s claim construction and see. “A reference that identifies data.” But does it do so by name other than numeric memory location? Looking at this, 01 directly refers to the location of the data; the entry is at memory location 01. So the claim construction doesn’t apply. This is not a symbolic reference.

Google: Where is that entry 01 located?

August: A reference located in the instruction stream.

Google: Where does it point?

August: An entry in the field ID table in the data portion of the program.

Google: Let’s move to the field ID table. Do the data there qualify as symbolic references?

August: A two-part question as there are two pieces of data: yellow and magenta. Start with 02. It is a reference that identifies data, but 02 is the location of that data, so it’s not a symbolic reference.

Google: What about the 76 in the field id table?

August: The 76 also refers to data, identifies data. 76 is the location in the table in which is occurs, so it is also the numeric memory location.

Google: Is the 01 in the instruction stream referred to as an index?

August: Yes. It’s an index into the table. [This is basic C pointers stuff.]

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

August: Both are locations. Offset may be used more commonly when talking about how many bytes into a table you want to traverse. Index more commonly used for tables with larger size entries.

Google: At entry 76 in the string id table, is that a symbolic reference?

August: No, a numeric reference. Doesn’t fit the construction because it identifies the data by location.

Google: String data at entry 8 (string “fun” again). Is that symbolic reference?

August: It is a reference that identifies data. It’s not shown on this board, but I know from looking at the code that it is. To find “fun,” we need to resolve it by looking for the location where it refers to. In resolve.c, this is resolved dynamically, so this does qualify under the claim construction as a symbolic reference.

Google: What about in the course of dexopt? Would it qualify as a symbolic reference?

August: Not if it is resolved statically. Dexopt is a static linking process, so it operates statically and not dynamically.

Google: Were you here for Dr. Mitchell’s testimony? Did you hear him explain that some of the dexopt references were symbolic references?

August: Yes. Dr. Mitchell is saying that all these are symbolic references.

Google: How do you explain the difference in your opinions?

August: Mitchell is applying the court’s claim construction differently.

[Puts the chart away and Dr. August goes back to the stand]

Google: Let’s talk about resolve.c. Did you review this list of functions? What are they? [dvmResolveClass(), dvmResolveMethod(), etc…)

August: I reviewed all of them. These are the methods/functions that take numeric references from the instruction, goes through the process we just did, and along the way may resolve a symbolic reference in the data just like “fun” over there.

Google: Do you agree with Dr. Mitchell that these functions infringe the ‘104 patent?

August: No. They do not resolve symbolic references. Each function takes an index from the instruction and those indexes are numeric references, not symbolic.

[Shows TX 737: Dalvik VM Instruction Formats. Page 2, syntax section.]

Google: Does this tell you what composes an instruction?

August: Yes. Syntax tells you what makes up an instruction: “each instruction starts with an opcode and...” Defines instructions as I understand them.

Google: “Arguments which indicate a literal constant pool index…” What is this talking about?

August: Talks about the arguments in some instructions. These arguments are indexes into certain constant pools like the string pool index and the type pool index. These are the same thing we were just talking about in resolve.c

[Third page. Opcode formats.]

August: There are a limited number of shapes that opcodes can take. One is the 22c format. One of those is “op va vb type@cccc” or “op va vb field@cccc.”

Google: Have you seen a comment in the code about symbolic references or resolution in Dalvik?

August: Yes. Numerous times.

Google: Does this suggest the ‘104 patent may be infringed?

August: No. Resolution occurs on symbolic references in the instructions, not in the data.

[Looks at Dr. Mitchell’s slide with the comments. ] It only takes about resolution like we see elsewhere, not symbolic references.

Google: Are there symbolic references ever in instructions?

August: No. I’ve looked at all the instruction formats and can say that the instructions do not contain symbolic references.

[Another set of resolve.c comments.]

August: Does not suggest that there are symbolic references in the Dalvik bytecode.

Google: Claim 11. Does resolve.c infringe claim 11 of the ‘104 patent?

August: Claim 11 requires that instructions contain dynamic references (“said instructions containing one or more symbolic references”. Dalvik instructions do not.

Claim 39. Also not infringed by resolve.c for the same reason. Claim requires a “symbolic field reference” in the instruction. A symbolic field reference is a type of symbolic references. No symbolic references here.

Same song and dance with claim 40, 41. No symbolic references in the instructions.

Google: Changing gears, let’s talk about dexopt. Do you believe that infringes the ‘104 patent?

August: No. For two reasons. The first is the same we’ve been discussing: instructions do not contain symbolic references and these claims require that they do.

Google: Do the dexopt docs suggest that there are no symbolic references in the instructions on which it operates?

August: It makes that suggestion.

[A comment in dexopt code. Argument @cccc is a constant pool offset. Showing where that is on the example dex code chart. ] Slide 48 from Dr. Mitchell. Showing instructions produced by the rewriting process in dexopt. Exchanging one offset/numeric reference for another.

Google: With respect to the arguments that go into these opcodes, how are they changing if at all?

August: Dexopt goes through the instructions. When it finds an iget, it takes the numeric memory location, goes through the process we did on the board, does resolution when it gets to that “fun.” The result of that is an offset. It writes that offset into the instruction and changes the instruction to an iget_quick.

Google: Is it rewriting the field@cccc instruction?

August: Yes. It takes that index into the field id table (numeric memory location) and replaces that into an offset. An offset replaces an index.

Looking at the same thing using the example in the Dalvik docs. Same conclusion.

TX 46.106. A header file from Dalvik that lists the instruction formats. Shows where the formats we’re talking about are listed.

Google: What do these documents suggest to you about whether symbolic references are used in Dalvik bytecode instructions?

August: Line 57 and 58 show that the instructions contain a memory index/field offset, not symbolic references.

Google: What’s the second reason you mentioned earlier?

August: Claim construction says that resolution occur dynamically.

[Oracle renews its standing objection to this claim construction.]

Google: Why does dexopt do static resolution?

August: It does static linking, must run before the program executes.

Google: You said linking? Does linking involve resolution?

August: The resolution process involved doing a search to find “fun.” We needed to link “fun” as referenced here with the location where it is defined. Linking is one form of resolution.

Google: Did you consider Dan Bornstein’s description of dexopt?

August: Yes. He talks about it as a static process, install-time work.

TX 32 slide 35. Install-Time work: “static linking”

This is consistent with my examination of the code. Static linking is what dexopt does. Dexopt operates on the application to do this resolution when it arrives on the phone.

TX 35: Bytecode for the Dalvik VM

When installed on a running system, some instructions may be altered “as an install-time static linking optimization.”

[Google pulls out a bunch of places in a whole bunch of docs where it says “static linking”]

Google: Does the Dalvik optimizer do any optimizations that can only be done at runtime?

A: No. It only does the ones with information that can be inferred statically.

Back to the claim charts.

Google: Does dexopt infringe claim 27 of the ‘104 patent?

August: No. Instructions do not contain symbolic references and the resolution is not occurring dynamically.

Google: Now claim 29?

August: No. [Google’s slides - draws a cute red X next to the claim after he says this]

Google: The ‘104 patent is a reissue correct?

August: Yes.

Google: Looking at the patent’s cover. Says a reissue of the ‘685 patent. Are those claims here?

[Oracle objects that this isn’t in the report. Google can talk about at closing but not now. ed: Relevant because Lindholm refers to the ‘685 patent in one edition of his book, IIRC.]

Q: Are you familiar with Mr. Van Det and his performance benchmarking?

A: Yes. There are three issues with his results: First, measurements were performed on the VM, but the VM isn’t always running. So the results are overstated.

What does it mean that the VM isn’t always running? There’s native code, the just-in-time compiler. During those operations, the VM’s performance is not an issue.

Second, benchmarks are not the same as the applications that users use. The benchmarks are at best an approximation.

Third, He deactivated part of Android that’s not used here: the JIT. This is problem because the JIT performs many optimizations. It’s not fair to turn off the JIT for these tests. The JIT is not accused of infringing the ‘104 patent.

Google: What does the JIT do?

August: It observes the instructions being executed. If it seems some are being executed frequently, it stops the VM, grabs those instructions, and converts them to native code, which can execute more efficiently.

Q: What would turning it off do?

A: The JIT can give significant performance improvements.

Cross-examination of Dr. August by Oracle:
[Yay, we’re back to the flip chart with bytecode]

Oracle: What does the “52 01” mean?

August: Opcode and a modification on that action. i_get 01

Oracle: What does that mean?

August: Take the index in the instruction, find the location in the field id stable to get an offset, take that offset and apply it to the instance object, and put whatever is there in another location called a register.

[switching charts]

Oracle: We changed “fun” to “y” at the judge’s request, but that doesn’t change anything.

So i_get 01 means obtain the value of the field from the instance object and place it in the register?

August: That’s the last step in the process, yes.

[Oracle counsel trying to figure out how to draw the instance object on his chart]

Oracle: Does 01 uniquely represent the value of a field in the instance object?

August: No.

Oracle: So 01 could get you randomly different fields in the instance object.

August: No, it doesn’t work like that. But if you have a second dexopt file that refers to the same instance object, it may be 08 or something else.

Oracle: So is 01 the offset in the instance object?

August: No, it is not.

Oracle: The purpose of the i_get instruction is to obtain data from an instance object?

August: Yes, that’s the last step.

Oracle: Again, the 01 is not a numerical value in the instance object is it? [really triumphantly]

August: No. It’s a location in the data table.

Oracle: When Dan Bornstein testified, did you detect any inaccuracies?

August: No.

Oracle: And same with Andy McFadden?

August: No.

Oracle: Looking at figure 1A of the ‘104 patent, a load operation. Operand is 2. 2 is not the data being obtained?

August: True.

Oracle: The 2 is a numeric memory location?

August: Yes.

Oracle: So the data being obtained here is the actual value in the data object (17)?

August: True.

Oracle: Now figure 1B: “load y” -- Is y a symbolic reference?

August: Yes.

Oracle: The actual data to be obtained is the value 17 here too, right?

August: Yes.

[Google objects to the term “actual data.” Oracle rephrases]

August: The 17 is not used to find the location of itself. The data in the data object is not used to determine the correspondence between the symbolic reference and a numeric memory location. So 1A refers to the data as a numeric memory location while 1B refers to it with a symbolic reference. [Basically, Oracle is trying to get him to agree as much as possible and pointing out that the end result is the same as that described in the patent.]

[PJ: May I just point out that the end result being the same isn't the issue with a patent. It's how you get there.]

[15-minute break for the jury. This is Google’s last witness. Oracle will have a rebuttal case (maybe an hour) and Google will have some cross there. May have time for the closings today.]

Huddles all around. Google has obtained a case of bottled water, while Oracle makes do with the few pint-sized bottles on their tables. Google slideshow guy reading Yahoo News and Mail on his computer. The court reporter manages to lock herself in the courtroom. She knocks on door, and along comes the judge ready to start up again. Oops.

Some progress! Subject to a condition, parties have agreed to make indirect infringement follow automatically from a finding of direct infringement (inducement or contributory). This would streamline things for the jury. Condition is that both parties need to reconfigure closings. Both would need to close tomorrow. That’s what we do. Indirect infringement is out of the instructions and jury form. If the jury finds direct infringement, the court shall enter a judgment for both direct and indirect infringement.

So if the jury finds infringement, Google would be liable for the handsets? Some quibbling over the exact intent, but they are basically in agreement.

Oracle asks for a sidebar.

Judge Alsup: Is this something the witness can’t hear or something the public can’t hear? [jury is not back yet] No sidebar happens. Would be binding on Google but not on Motorola or anyone else because they aren’t present.

Jury’s back and so is Dr. August.

Dr. August Cross, Continues

Still looking at the figures from the patent. Tries to get August to say that the i_get instruction stores the “actual field data” into the register. Google objects again to “actual data.” Oracle shows McFadden’s testimony where he talks about the “actual data.” Oracle: So the i_get instruction has as an operand the field index?

August: Yes.

Oracle: And you heard Mr. McFadden testify that the field index is not the numeric memory location of the actual field data in an object?

August: True.

[Oracle asks this exact question again for emphasis]

Comparing parts of the diagram to the patent. Agrees that the values in the instance object are like the “17” in the patent diagram.

Oracle: You testified that Dalvik bytecodes do not contain dynamic references at all?

August: Right.

[His report is a hefty tome.]

His report says “Dalvik VM does not define an instruction format that contains a symbolic reference.” In other words, you can’t put “y” or “fun” into the instruction stream. That’s because operands must have a fixed length.

Oracle: In fact, the format of the dex compiler here is in all respects the same as that of the Java compiler?

August: In terms of this specific instruction, fundamentally yes.

Oracle: So the operands are a fixed length in both a dex file and a .class file?

August: I believe so.

Oracle: So it would also be true for a Java bytecode instruction? Is it your testimony that there are symbolic references in the instruction stream output by the javac compiler?

August: I believe it does not output symbolic references.

Oracle: So Java doesn’t do this either?

[Google jumps up at this. Says it doesn’t matter what Java does. Judge Alsup sustains: the only thing that matters is the patent, not whatever Java does.]

Oracle: You agree that Dalvik instructions contain references to methods, classes, fields, strings?

August: They can contain references to these things in constant pool tables.

Oracle: And can those be symbolic references?

A: No. They are actual locations.

[Oracle is basically trying to get him to agree that it uses a symbolic reference because none of the operands are the numeric memory location of the field data. Dr. August says it’s clear that field@cccc is referring to the field id table.]

[Someone in front of me has done a great pen and ink drawing on his legal pad of the judge, Dr. August, and a sleeping jury. I’m actually impressed the jury is this with it given the insane level of pedantic quibbling we’ve gotten into.]

Oracle: So dexopt replaces a field@cccc with a byte offset that is a numeric reference?

August: Yes.

Oracle: So your testimony is that dexopt rewrites the i_get instruction into an i_getquick instruction and converts the operand into a numeric reference?

August: Yes.

Oracle: And do you agree that a dex file contains symbolic references when it arrives on the device?

August: Yes.

Oracle: Do you agree that the Dalvik VM resolves functions dynamically?

August: It does.

Oracle: And you were here when Dan Bornstein testified that dexopt is part of the Dalvik VM?

August: Yes.

Oracle: And you agree?

August: They share the same code.

Oracle: And dexopt loads the dex file into the Dalvik VM?

August: No. Dexopt processes the file that is placed on the device.

Oracle: Dexopt processes the file while the Dalvik VM is running, true?

August: Not for the same program.

Oracle: That’s not what I asked. Is the Dalvik VM running?

August: Sometimes.

Oracle: Let’s see what Mr. McFadden said. He said that Dexopt processes the dex file while the Dalvik VM is running. Do you disagree?

August: I don’t disagree. I’m just being more specific.

Oracle: Dexopt loads the dex file into the Dalvik VM, true? When dexopt loads the file into dexopt, it loads it into the Dalvik VM?

August: If you mean the code that is a part of Dexopt, yes.

Oracle: Let’s talk performance testing. You didn’t do those things yourself that you think should have been done differently?

August: No.

Oracle: And you did no performance testing yourself at all?

August: No.

Oracle: And Google, with all its resources, didn’t provide you with any performance data for your report?

August: No.

Oracle: Both benchmarking tools are standard tools? Google uses them internally for their own tests?

August: Yes.

Oracle: Back to instruction “52 01.” What this instruction does is get the actual field data and place it in a register?

August: True.

Oracle: And the 01 is not the numeric memory location?

[Tries to force him to agree that since the “01” is not the final numeric memory location, it must be a symbolic reference.] August: 01 is a reference and it does identify data.

Oracle: So the reference 01 identifies that data by a name other than the numeric memory location of the data?

August: The reference identifies data, but the data is the field id table. That’s not applying the court’s construction.

Oracle: Start with the first half of the definition: “A reference that identifies data other than by the numeric memory location of the data” (second part is that it does so dynamically). So let’s assume the data is actual field data in the instance object. The 01 does identify that data, true?

August: No. It refers to the field ID table.

Oracle: Even though “52 01” will retrieve the field data from the instance object, your testimony is that 01 doesn’t refer to the data in the instance object?

August: That’s correct.

[Everyone’s head starts to explode keeping track of what assumptions we’re making.]

Oracle: You don’t think the 01 identifies the data? So when Mr. Mcfadden testified about how this all works, you disagree with him?

August: No.

Google’s redirect of Dr. August:
Google: Points to claim construction. Does the entry in the string id table refer to data by a name other than the numeric memory location?

August: No, it’s a numeric reference.

Google: There’s been a lot of talk about the “actual field data in the instance object.” So let’s talk about the instance object. This entry at slot 18 (an offset), what can be in that instance object by way of data?

August: It could be a symbolic reference, a numeric reference, or other non-reference data.

Google: And in Dalvik, is the data in these entries always non-reference data?

August: No, it’s not. You can write programs that contain references in instance data of objects.

[Walks through the process of resolving variables again, describing everything is numeric memory locations]

Google: And in dexopt, can you explain whether and how the VM is running while dexopt is processing Dalvik bytecode?

August: The VM may be doing other things as it relates to other programs. When your device is on, many things are running. But as it relates to the program being installed, dexopt may start and stop before the VM interpreter can interpret it.

Google: TX 739, about the “backdoor into the VM.” What does that mean?

August: The VM has a lot of code. It is like a library and you can think of that library as having an API. The dexopt program is much smaller because it can leverage the code in the VM library.

Google: The jury is all too familiar with APIs… [chuckles]

August: And when it says here that dexopt completes, what does that mean? So not only does dexopt not execute dynamically, but dexopt terminates (stops its own execution) and is no longer running when it is done.

Google: Again, is dexopt dynamic or static?

August: Static. Everything it does is before the first execution of the program.

Google: Does dexopt resolve symbolic references?

August: No.

Google: Why do you say no?

August: Because it operates statically rather than dynamically. So it doesn’t satisfy the definition under the court’s claim construction.

Oracle tries to question Dr. August again.

Judge Alsup: Wait a minute. How many times are you going to go through this? They agree on five more minutes.

Oracle's Last Try to Shake Dr. August:

We go through the resolution process again, establish that the end result is still the same.

Oracle: After i_get is resolved, it takes you into a unique location in the instance object?

August: Right. [Tries to explain further… Gets cut off]

We’re done with Dr. August, much to his relief.

Google rests.

Judge Alsup: another milestone has been reached. Oracle has a rebuttal case, wants to recall Dr. Mitchell.

So stop back later, and we will finish. Meanwhile, Oracle would like us to look at their opening slides [PDF]. Comments are highlighting that there has historically been a monetary connection between Oracle and Stanford University [Cf. PDF], where Dr. Mitchell works.

Update 3: And TechDirt provided a link to James Grimmelmann's analysis of a ruling on Friday regarding fair use and de minimis use by a state university:

On Friday, the long-awaited decision [PDF] in the Georgia State e-reserves case (a.k.a. Cambridge University Press v. Becker) dropped. By way of context, the case is a challenge by three academic publishers (Oxford University Press, Cambridge University Press, and Sage Publications) against Georgia State University’s e-reserves policy....

First, over a third of the claims didn’t even make it to the fair use stage at the heart of the case. In many cases, the publishers were unable to prove to the court’s satisfaction that they owned the copyright in the portions of the books that were copied and uploaded. Sometimes they couldn’t produce a timely registration certificate and there were proof problems with originality; sometimes they couldn’t find a work-made-for-hire agreement or copyright assignment from the authors of individual chapters in edited volumes. The court was unsympathetic: no documented chain of title, no lawsuit. There’s a looming e-rights mess, loosely akin to the robosigning mess around ownership of securitized mortgages: in both cases, the putative owners don’t have all their papers in order. This opinion either recognizes or contributes to the mess, depending on your point of view.

Other claims dropped out before the fair use stage because they were uploaded to the e-reserves system but never downloaded by students. The court dismisses these from the lawsuit as de minimis, explaining that these uses by the University, while technical implicating the copyright owners’ exclusive rights, don’t affect the incentives for authors to create. This puts more teeth in the de minimis doctrine in copyright: it goes beyond the view that de minimis means “not substantially similar.” It also strengthens the argument that “internal use” copies never used to reach to an audience that reads them for their content don’t infringe. Think, for example, of the HathiTrust’s archive of scans from Google Books.

Anyone know why this reasoning wouldn't justify the jury's finding about the test files as de minimis, since they never shipped with Android and so no user ever used them?

Update 4: Here's the final report from Zach, on Oracle's rebuttal testimony:

Dr. Mitchell, recalled.

Oracle: On Friday, we asked Dr. August about the difference between your positions on symbolic references. Did he fairly characterize your opinion?

Dr. Mitchell: No.

Oracle: So he was saying that you were trying to get “fun” or “y” over here into the instruction, is that what you’re trying to do?

Dr. Mitchell: No it’s perfectly happy right where it is.

Oracle: Do Dalvik instructions contain symbolic references?

Dr. Mitchell: Yes.

Dr. Mitchell: What are they?

Dr. Mitchell: The field indexes.

Oracle: But those are numbers, does it matter?

Dr. Mitchell: Not at all, a number can be a symbolic reference.

Oracle: What about the claim construction that says a number can’t be a symbolic reference?

Dr. Mitchell: Nothing. A number is a perfectly good name. Adding the dex file to the poster. It includes the instructions, list of opcodes and operands, but not the resolve field table.

Oracle: Is the field index in a Dalvik instruction a symbolic reference?

Dr. Mitchell: It is, according to the court’s construction. It is a reference and it identifies data. It is a name (01) and that name is not a numeric memory location for the data (if it were, we wouldn’t have to resolve it) and it is resolved dynamically rather than statically.

Oracle: What’s the issue with resolve.c with respect to the ‘104 patent?

Dr. Mitchell: The only issue is whether the field references are symbolic references are not. And that just turns on what we mean by data.

[Oracle: Gets a poster that shows a dex file and some portion of a resolution process, describes resolve.c. Asks Dr. Mitchell to revise it.]

Dr. Mitchell: Describes “data” as the “constant pool” and separates the resolved fields table since it is created in memory at runtime by the Dalvik VM, not in the dex file. Constant pool comes from the source code. Source -> java bytecode (which has constant pools) -> dx tool (reformats constant pools)

Writes an example that uses regular high school geometry. Mitchell: “I don’t know if you enjoyed high school geometry or not. I happen to, but that’s just me.” [Doesn’t look like the jury was so fond of it]

So we’re drawing points with x and y coordinates, the type of each is a byte. [Draws two fields]. To do something, I write a method movingUp()

[ed: we can’t actually see what he’s writing from the gallery].

It looks like y=y+1. So this class has two fields and one method that uses one of the fields. The instance field y is used here and the program has to get its value in order to add 1 to it. So this particular part of it is turned into some iget, say iget field@01. Field@01 is really the Dalvik instruction’s version of y. That 01 is a symbolic reference. It needs to be resolved in order to execute the iget instruction, have to find where the actual data is in the object.

Oracle: So what does the Dalvik VM do with the memory location after determining it?

Dr. Mitchell: It obtains the data according to this numeric references. The next time this instruction is executed, the VM looks in this table and doesn’t need to do the search process again. This works for this instruction and any other one with the symbolic reference field@01.

Back to the definition of symbolic reference. Dynamic is not disputed for resolve.c. Dr. Mitchell writes the definition out even though it’s on all our screens. Shows the name is 01. Memory location is 48. 01 not equal to 48. Therefore he says it is a symbolic reference, not a numeric reference.

Oracle: And how does this happen in dexopt?

Dr. Mitchell: Basically the same. The difference is that the I get instruction is rewritten and the symbolic name is written to a numeric reference. So iget is rewritten to igetquick and the 01 is changed to the memory location. But all the references have the same meaning whether dexopt runs or not.

Oracle: Does dexopt run dynamically?

Dr. Mitchell: Yes. It is the dynamic process of searching through these references and as a portion of the Dalvik VM. It resolves the location of classes loaded into memory at run-time. It’s all dependent on information known at runtime and not known independent of the platform of the code. I don’t have anything against Dr. August, but if I could not share his water glass, that would be good…

Alsup says we’re trying to economize.

On to the ‘520 patent.

Dr. Mitchell: He says the dx tool simulates bytecode. Something can be pattern matching as a portion of simulation.

Dr. Mitchell: As I read the code, the process is simulation.

Oracle: Andriod has no stack operations. What’s the relevance?

Dr. Mitchell: I don’t see why a stack is required for a simulation. A simulation isn’t true execution of a program. I believe the ‘520 patent is infringed because the implementation of the dx tool meets all the limitations of the claims.

Google’s Cross-Examination of Dr. Mitchell, Robert Van Nest questioning:

Google: Between your first report and your second report, you had access to additional information?

Dr. Mitchell: Yes.

Google: Before you wrote your reply report, you had access to all of Dr. August’s opinions?

Dr. Mitchell: No.

Google: But you had his report, reviewed it, and so this second report was written only after you reviewed Dr. August’s report?

Dr. Mitchell: Yes.

Google: You’ve previously said that this operand is in the instructions?

Dr. Mitchell: Yes.

Google: And you identified that operand as an index?

Dr. Mitchell: Yes, a field index.

Google: So an index into the field table shown here on the slide?

Dr. Mitchell: Yes, a simplified version.

Google: And it’s a reference to a location in the field table?

Dr. Mitchell: It’s an index into that array, yes.

Google: And a class index is an index into a table, works much the same way?

Dr. Mitchell: Yes.

Google: And a method index, also an index into a method table, works much the same way?

Dr. Mitchell: Yes.

Google: And the string index…

Dr. Mitchell: Yes.

Google: In your first report, you repeatedly referred to these indexes as numerical references?

Dr. Mitchell: The only place I can think of where that is in the paragraph that, as I explained, it contained an error, which I corrected.

Google: Have you gone back through your report over the weekend and looked to see whether you referred to these as numerical references?

Dr. Mitchell: No.

Puts up part of Dr. Mitchell’s first report. Shows a couple of sections that say “numerical references” and “method indexes”.

Google: So that’s two places where you looked at the Dalvik bytecode instructions and called it a numerical reference?

Dr. Mitchell: Yes.

Google: Is that also a mistake?

Dr. Mitchell: No.

Google: [Shows another place where it says “numerical reference string_idx.”] Almost every time you saw an index like these in the Dalvik instructions, you called it a numerical reference?

Dr. Mitchell: I don’t recall that.

Goes to paragraph 284, another reference to a field id with a specified index as a numerical reference. Dr. Mitchell says it’s something different. ID and idx [meaning index] are two different things. Apparently he meant a field id with a specified index; arguably the report is missing a comma.

Google: Can you think of any example in your report where you call an index anything other than a numerical reference?

Dr. Mitchell: I believe there are some paragraphs that do that.

Google: And your second report and your testimony last week and this week are only after you had the opportunity to review Dr. August’s report?

Dr. Mitchell: No, that’s not my recollection.

[We get into a kind of ridiculous circle of questions looking at the example. test1=”Hello World” is compiled to Java bytecode and then into Dalvik bytecode, but the references to “test1” in the bytecode are just comments, used for debugging. The executable bytecode itself doesn’t say “test1.” The comments say “test1” so that developers can use the same name when testing/debugging their code. Van Nest doesn’t understand this.

[15 minute break]

Judge Alsup before the jury comes in: “We’ve got to finish this today.” Van Nest says he’s on track for the same thing. [Chuckles all around.]

[Jury’s back]

Google is still cross-examining Dr. Mitchell:

Found another spot in his first report that says “numerical reference.” (e.g., it says “numerical reference (method id with specified index)”) Arguing over the exact intent. Dr. Mitchell keeps saying that’s not what he meant, but agrees that it could be read that way.

Looking at the ‘520 patent, claim 1.

Google: Fair to characterize the executable code as pattern matching?

Dr. Mitchell: Not exactly.

Google: There are patterns that appear in the dex bytecode that is analyzed?

Dr. Mitchell: There is a repeating pattern of four instructions.

[Shows the Java bytecode for those four instructions. Dr. Mitchell argues that they aren’t a repeating pattern.]

Google shows the next four lines and they are the same, just the arguments incremented by one. It repeats another few times just in this slide.

Google: Could this be analyzed using pattern matching?

Dr. Mitchell: Potentially.

Google: In a Java bytecode system, instructions operate by manipulating the stack?

Dr. Mitchell: Yes.

Google: And in the dx tool, there is a simulator file that you’ve spent a lot of time talking about. This set of code does refer to “getting the stack,” correct?

Dr. Mitchell: Yes.

Google: parseNewArray() is a different set of code from the simulator class? Different code in a different file?

Dr. Mitchell: Yes.

Google: And in the executable source code, not in any comments, of parseNewArray(), there are no references to getting a stack or popping or pushing or anything like that?

Dr. Mitchell: I don’t see it, no.

Google: Have you been able to determine whether any other file in the dx tool calls the parseNewArray() method?

Dr. Mitchell: I didn’t see that as important to look into.

Google: So you can’t tell us if any other classes that don’t have anything to do with simulation call that code?

Dr. Mitchell: I didn’t look into that.

Oracle’s redirect of Dr. Mitchell:
Oracle: You were asked about the errors in your report. Let’s turn to Vol. 2, Exhibit A of the opening report, overview section (p. 38). What were you citing here to make your point about symbolic references?

Dr. Mitchell: This citation is to a source code file called reduceConstants.c, and at the beginning of that file is a description. I believe Mr. McFadden wrote this. It talks about the indexes and invoke_virtual_instruction, which is similar to the iget with a symbolic reference.

Oracle: What does this say about a symbolic vs dynamic reference?

Dr. Mitchell: This explains clearly that these indexes are symbolic references.

Now to Vol. 1, paragraph 283: “Next the function…determines or resolves symbolic references (instance fields) in numerical references…”

Paragraph 252: Also completely in-line and similar to what Dr. Mitchell was saying earlier today. Optimize.c resolves the field index in the constant pool to a byte offset

Paragraph 250: Calls the process a resolution of a symbolic reference. Written well before seeing Dr. August’s report.

Dr. Mitchell done.

Oracle rests its rebuttal case. Google huddle time. Google rests.

Judge Alsup: We have reached another milestone, which means no more evidence. Jury can use everything they learned in the first phase as well. Too late for closing arguments. 1:15 hour per side for closing arguments, will probably go to the jury sometime between 11-noon. No deliberations or talking about the case in the meantime.

[Jury dismissed]

Oracle asking about a Rule 50 motion (judgment as a matter of law). Outline to be submitted tomorrow morning, briefs due 5pm on the 16th, oppositions at 5pm on the 17th for both sides. Van Nest may want more time and the 18th is ok if he needs it.

Clerk hands out new jury instructions to reflect the stipulation on indirect infringement. Now no references to “direct infringement,” just “infringement.”

Judge asks for parties to come back at 1pm for a last chance to point out anything they want changed. Does not want to rehash and reargue things that have already been beaten to death. Accept your loss with good grace.

[PJ: That's Greek to Boies Schiller, from all we've seen. It reminds me of the Magistrate Judge in SCO v. IBM asking both sides to play fair, as in football, according to the rules.]

Other preparations for the jury, getting exhibits indexed and organized. Judge says the last time deliberations took quite a bit longer than I thought it might, but we don’t know. Could be 20 minutes or could be a week.

Judge reminds the lawyers to knock it off with the numerous “I think” and “I believe” statements in the closings that both parties used last time.

Oracle says that the jury was told some things about indirect infringement in openings, wants the judge to tell them it doesn’t apply. Parties to agree on a single sentence on that for the judge to read. Van Nest jokes that they’ll congratulate the lawyers for their hard work.

Oracle has about 40 minutes left, while Google has more than two hours.

[I didn’t stay for the 1 pm session to finalize the jury instructions, but journalists on Twitter indicate it was pretty quick and simple.]

We'll post those documents in a bit.

Update 5: 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.


  


Reports from the Oracle v. Google Trial - Day 6, Patent Phase - Drs. August and Mitchell , ~pj - Updated 5Xs | 439 comments | Create New Account
Comments belong to whoever posts them. Please notify us of inappropriate comments.
Corrections Here! (besides 5/4 --> 5/14!) (N/t)
Authored by: Anonymous on Monday, May 14 2012 @ 01:22 PM EDT
Grammar Nazis, here's your chance to be helpful....and pick out the typos....

[ Reply to This | # ]

Corrections
Authored by: Kilz on Monday, May 14 2012 @ 01:28 PM EDT
Corrections need to be started by a logged in user. For
mistakes.

[ Reply to This | # ]

Off Topic
Authored by: Kilz on Monday, May 14 2012 @ 01:29 PM EDT
For all posts that are not on topic.

[ Reply to This | # ]

Newspicks
Authored by: Kilz on Monday, May 14 2012 @ 01:30 PM EDT
Please mention the news story's name in the title of the top
post.

[ Reply to This | # ]

Comes
Authored by: Kilz on Monday, May 14 2012 @ 01:32 PM EDT
Please post all transcriptions of Comes exhibits here for PJ.

[ Reply to This | # ]

I think the Judge is Confused
Authored by: rsteinmetz70112 on Monday, May 14 2012 @ 01:47 PM EDT
I have been wondering about what the Judge is thinking. This report makes it
sounds like he is confused.

Why doesn't he let SSO damages go to the Jury and then he can decide to overrule
them if he wants to?

If he doesn't overrule them then the trial will not be complete and there will
need to be a new trial with a new jury to decide damages.


---
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 | # ]

The system is hopelessly flawed
Authored by: Anonymous on Monday, May 14 2012 @ 01:49 PM EDT
The system is hopelessly flawed when a judge and jury are obligated to accept a
lie as the truth simply because it was not officiallty challenged.

If a witness stated that the moon is made of green cheese would the jury be
obligated to believe it unless there is an expert witness to contradict it? If
that is true, then justice is impossible. It is all just nonsense and word
games for the benefit of lawers. Ick!

[ Reply to This | # ]

Tweets from the courtroom
Authored by: feldegast on Monday, May 14 2012 @ 02:00 PM EDT
https://twitter.com/#!/Feldegast

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 | # ]

Jacobs tells another howler
Authored by: Anonymous on Monday, May 14 2012 @ 02:01 PM EDT
Jacobs: Dynamically doesn’t mean the same thing as run-time. We’re misunderstanding the basic rules of set theory.

Say what? Of course it means the same thing as run-time. Static optimizations happen before the program is run (not at run-time). Dynamic optimizations happen while the program is running (at run-time).

And I have no idea what he meant about set theory (I suspect we'll have to wait 3 months for the full transcript before we'll know exactly what he was trying to say, and whether it made any sense or not.)

[ Reply to This | # ]

Closing Statements
Authored by: DannyB on Monday, May 14 2012 @ 02:23 PM EDT
" . . . an in conclusion ladies and gentlemen of the jury, if you do not
find any patent infringement, then there will be no need for a damages phase and
you can go home."


---
The price of freedom is eternal litigation.

[ Reply to This | # ]

Is justice really blind, or do celebrity lawyers get more leeway?
Authored by: Anonymous on Monday, May 14 2012 @ 02:46 PM EDT
Just wondering...

[ Reply to This | # ]

What's the point of a jury ...
Authored by: Anonymous on Monday, May 14 2012 @ 02:53 PM EDT
... if the judge can overrule them? Why bother with the
charade?

[ Reply to This | # ]

Stanford CS Dept. reputation tarnished?
Authored by: Anonymous on Monday, May 14 2012 @ 03:39 PM EDT
Why is the Stanford University Director of Graduate Studies of their CS
department (from Dr. Mitchell's web page) actively working to change copyright
case law to include software API's? Furthermore, not only does he seem to
believe that software should be patented, but appears willing to confuse a jury
about the importance and application of some very weak (obvious) software
patents.

I would think that a professor of Computer Science would be very
aware that over-reaching copyright law and weak patent claims damage the
computer industry.

Could donations to Stanford be an issue again? (search the
web for: "In re Oracle Corp Derivative Litigation?")

[ Reply to This | # ]

Reports from the Oracle v. Google Trial - Day 16 ~pj
Authored by: eric76 on Monday, May 14 2012 @ 03:47 PM EDT
In light of the recent EU decision, what is the likelihood that Oracle will come
to their senses and decide that it is not at all worthwhile to take the API
portion back to court in another trail?

[ Reply to This | # ]

Credibility and the jury
Authored by: tknarr on Monday, May 14 2012 @ 03:59 PM EDT
I don't see why a jury can't decide they don't believe a word that man said, if that is their decision. The jury instructions say that is their job, to evaluate credibility. If they didn't believe Dr. Mitchell, as I didn't, why can't they so decide? I know. Logic. Mark tells me I'm off base on this. For the jury to reach a different conclusion, he explained to me, there would have to be evidence that Dr. Mitchell's statement was unfounded (Google's burden of proof) or that there was contradictory evidence (Google's burden of proof). The jury can't simply decide that Mitchell's testimony was not credible absent some challenge or contradictory evidence. To which I say, why not? If on other issues, where there was evidence, they listened and decided nothing he said was credible, why shouldn't that be their job and their right? Sometimes the law and logic diverge, as you may have noticed.

I'd have to agree with PJ in my bogglement. I'd note that as a juror I'd phrase it as "Google isn't the only side whose evidence I have to look at.". Dr. Mitchell's testimony is right there. He was on the stand. If that isn't evidence that I can consider when judging his credibility, what is? And if I decide, based on the evidence Oracle and Dr. Mitchell presented, that Dr. Mitchell's testimony isn't credible, why can't I as a juror do that? My judgement is based on the evidence presented in the courtroom, as part of the record. Oracle and the judge may not like the decision I came to regarding the evidence presented, but why would I not be allowed to make a decision based on the evidence and testimony that's part of the record?

[ Reply to This | # ]

Identification of a work - de minimus - statutory damages
Authored by: Anonymous on Monday, May 14 2012 @ 04:30 PM EDT
I am a bit confused by the apparent qualification of a file as a work, in the
context of the test files decompiled by Noser.
Did judge Alsup rule that copying in this context was not de minimus because the
whole work (one file) was copied?
If so, if this was done to 7 files, would that make Oracle eligible to a maximum
of 7 x $150.000?
Plus the 9 lines of rangeCheck code that apparently equal a whole work as well
for another $150.000?
It seems to me that splitting your work into a compilation of atomic works
(atomic meaning cannot be split any further) makes you eligible for billions in
statutory damages if your some of your work is copied.
Strange.

[ Reply to This | # ]

To Err Is Human
Authored by: sproggit on Monday, May 14 2012 @ 05:22 PM EDT
"The judge believed that he had to overrule the jury on the test files, because Mitchell said they were very important (--so important Google didn't even know they were there until Oracle told them since it wasn't Google who put them there, m'lords?), and he wrote in his order that no one contradicted that testimony, and that's why he had to rule as a matter of law that the evidence from Dr. Mitchell established the point. As we see here, Google is not taking any chances that it could happen again."
Several articles ago, we were told that Judge Alsup, having realised that he had made a mistake, came back to the counsel for both parties with a correction. I find it deeply disappointing that, with this Court at least, Counsel for the parties are held to a higher standard than the Court, and are not given the same opportunity to make such corrections.

I am sure that there are all sorts of reasons why it's not appropriate for a Court to give Counsel endless "wiggle room" during a legal dispute. We saw ample evidence of this when Judge Kimball presided over SCO vs. IBM and SCO vs. Novell. However, in the instant example, I find it somewhat puzzling that Judge Alsup has made a ruling against Google on the grounds, "You could have complained and you didn't."

My lack of legal training and ignorance of the finer points of courtroom etiquette are clearly going to shine through here, but this just seems disengenuous. For some reason I am reminded of that quip from Lt. Daniel Kaffee (Tom Cruise) in, "A Few Good Men":

"That's a relief! I was afraid I wasn't going to be able to use the 'liar, liar, pants-on-fire' defense."

[ Reply to This | # ]

Jury of their peers
Authored by: Anonymous on Monday, May 14 2012 @ 05:30 PM EDT
Google should have gotten a jury of their peers: programmers or project
managers.

[ Reply to This | # ]

update 2
Authored by: Anonymous on Monday, May 14 2012 @ 06:13 PM EDT
Wow.. reading the battle between Oracle and Dr. August was really something.
Sounds like he did a great job of being precise and not letting Oracle twist his
words to mean the opposite of what he said.

I'm surprised it was Oracle that tried to bring up the apparent fact of Java not
practicing the '104 patent either. I wonder what their argument was going to
be? "Our patent must cover what we thought it covers, and therefore it
must cover Google's thing too"? BSF seems pretty good at turning the
factual weaknesses of their case into strengths! Good thing it was irrelevant
and the Judge shut it down.

[ Reply to This | # ]

Dynamic vs Static
Authored by: Anonymous on Monday, May 14 2012 @ 06:25 PM EDT
I hope Google's attorneys realize that this is probably the easiest point to
make to the jury and really pound that into their heads in closing arguments.

[ Reply to This | # ]

Reports from the Oracle v. Google Trial - Day 16 ~pj - Updated 2Xs
Authored by: Anonymous on Monday, May 14 2012 @ 06:31 PM EDT

Oracle: When Dan Bornstein testified, did you detect any inaccuracies?

August: No.

Oracle: And same with Andy McFadden?

August: No.

That second no means the opposite of what I think August intended.

[ Reply to This | # ]

Update 3 - de minimis
Authored by: Anonymous on Monday, May 14 2012 @ 07:51 PM EDT
"Anyone know why this reasoning wouldn't justify the jury's finding about
the test files as de minimis, since they never shipped with Android and so no
user ever used them?"

The reasoning might apply. Unfortunately, since it's a different district, and
not even an appeals court decision, there's no requirement whatsoever for this
court to follow it...

MSS2

[ Reply to This | # ]

I am waiting for the Greek font comparison.
Authored by: Anonymous on Monday, May 14 2012 @ 07:55 PM EDT
Looky!!! The files are the same size, Yer Honor !!
A favorite of mine. use a Greek font to conflate it all.

[ Reply to This | # ]

Unbelievable!
Authored by: Anonymous on Monday, May 14 2012 @ 08:01 PM EDT
Dr. Mitchell must have been paid a fortune for this testimony. He should
be sacked from Stanford for this. His testimony under oath contradicts 50
years of theory and practice in computer science. A numeric index is NOT
a symbolic reference, that is a bald-faced lie. In all my years of following
Groklaw, I've never felt as disgusted as I do right now.

[ Reply to This | # ]

Nonsense word games
Authored by: Anonymous on Monday, May 14 2012 @ 08:39 PM EDT
If an array index is a "symbolic reference" then there is so much
prior art that Oracle's patent is worthless.

According to Oracle's theory, an address in most high level languages is NOT an
address, but rather a symbolic reference ... because on modern machines the
"address" used in the code is NOT the address in memory. The
page-table hardware converts these addresses to actual memory addresses on the
fly during execution.

So ... does this mean their patent covers any processor that uses virtual
memory, clear back to its introduction in the 70s?

[ Reply to This | # ]

Thanks, Zach!
Authored by: Anonymous on Monday, May 14 2012 @ 09:14 PM EDT
Thank you for making it to the courthouse and spending your day taking these
detailed notes for us!

Can a logged-in user please start a Thank-You thread? =)

[ Reply to This | # ]

Simple definition for symbolic references
Authored by: Anonymous on Monday, May 14 2012 @ 10:55 PM EDT

There are three types of references: direct, indirect, and symbolic.

A direct reference is one where the reference specifies the target directly. The reference may be an address, offset (i.e. an address relative to some commonly agreed address), or index (to an array or table; basically an address but specified in data units).

Indirect references occur when there is more than one direct reference to be followed to reach the target. Usually, the number of steps is known beforehand, but that is not necessary: some kind of an indicator to tell whether the target is the true target or a reference to follow, is enough. (Just because an indirect reference might have a variable number of steps, does not make it a symbolic reference.)

Symbolic references are those where you have a set of target symbols, and you must search the set for the exact target symbol to reach the target. The search operation is the key. If you do a search, you have a symbolic reference. If you do not do a search, you have a direct or indirect reference.

There are many ways to order the sets so that the searching can be done efficiently. The most common one is hash tables, where a key is first computed from the symbol, then this key is used to probe a location for the reference.

Perfect hashes are those that yield an unique location for each expected symbol, so one probe is quaranteed to get the correct slot.

Perfect hashing is the watershed line between indirect references and symbolic references. While a hash function is involved, if the search is always guaranteed to succeed (i.e. it is a perfect hash) in a single step, it is an indirect reference. On the other hand, because a hash function is involved in transforming the symbol, it is a search operation, resolving a symbolic reference.

In practice, only references using fixed or static perfect hashes are indirect references. This is rare, but used for example computer processor internal memory management (caches).

Dynamic perfect hashes are those that adjust to fit their dataset, the bag of symbols they are used with. They are quite rare, and most often include code that allows them to gracefully degrade to less than perfect hashing. It should be obvious, then, that the perfect hash in such cases is only a search optimization. Because there is clearly a search involved, references relying on dynamic perfect hashes must be considered symbolic references.

I hate it when graphic designers misuse scientific terms like "volume" or "weight" for completely subjective purposes. Having lawyers twist simple, clear computer science terms into something garbled and confusing, and having highly paid professors blatantly lie in support for only money, it just gets my blood boiling. Most of the Oracle "experts" deserve to lose their jobs, and let those who have the decency to not defecate over the work and research of their peers, to continue contributing to our respective societies.

[ Reply to This | # ]

A dogrel on the copyright inapplicability of decompiled code
Authored by: BitOBear on Monday, May 14 2012 @ 11:54 PM EDT
#!/bin/bash
# And so we do now find ourselves
# with rulings by the pair,
# refuted here with alacrity
# by member BitOBear.

# With this bash script imaginative filled
# expressions we shall see,
# offered under creative commons terms
# to you, the licensee

# The court has found that object code
# compiled from the source
# retains some kind of copyright
# beyond pure functions course

# The mouse celebrates it Pyrrhic victory
# and cheers "ours is the cheese of course"
# and in response the angry
cat << 'roared' > decompiled.java # "source"

/* see as a */ class /* we experts know */
// Compiler are blind
// to expressive assignations in
// the object code they bind

/* once object code is */ decompiled
/* and punctuation like this gone */ {
// The fact remains but functions' left
/* in the */ public final /* song */

/* The court does council */ String /* along
while jury verdict it now defames
for they could see what it could not
There's */ only_functional_remains

/* The compiler, you must now know,
// Is blind to expressive thought
/* It sees only a */ (String of_data)
/* within all the code that's wroght*/

/* The dance of punctuation has its bits*/{
// That confuse the new-come mind
/* Into thinking the machine doth think
/* but in */ return /* it's blind */

/* Within it code and messages it is wont to shout */
"nothing recognizably expressive remains "
+ "In this you must not doubt"
/* your pains of clever order don't matter here */


/* I have no thought */+ of_data
// here I know your heart must sink
// On style I do not opine
+/* as Machine, I do not think */

// Nothing is left once I am done
/* well nothing */" except the strings,"
+" even argument names are lost";
/* though braces wrap again all things */}}

// So for justice we do wait upon
// the drama has us bored
// The legal theories bounce about
// no heed for the expert cats that
roared

# Now we invoke the incantations
# first compile then extract
javac decompiled.java ; jad -noctor -nonlb -p decompiled.class
# in search of only fact

# If you don't have linux and java
# and you haven't added jad
# I'll save you all the trouble
# this demonstrations' just a fad

# below you'll find the output
# having run on -my- machine
# of this my demonstration
# and my whit that's o-so keen

====
// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: packimports(3) noctor nonlb
// Source File Name: decompiled.java


class decompiled {
public final String only_functional_remains(String s) {
return (new StringBuilder()).append("nothing recognizably
expressive remains In this you must not doubt").append(s).append("
except the strings,").append(" even argument names are
lost").toString();
}
}

[ Reply to This | # ]

Thought for the day.
Authored by: jvillain on Tuesday, May 15 2012 @ 12:08 AM EDT
So we have two, count them two weak patents being litigated in this trial and as
a programmer and sysadmin I have to stop and chew on some of this stuff for a
while to make sure I have the actual facts straight and I need to rely at least
50% on stuff I have learned out side of the trial. To the Jury I am sure you
could have replaced this whole argument with a discussion of String Theory and
they wouldn't know the difference. Two patents.

Now if you remember back before the judge actually got his hands on this case
Oracle was suing over a hundred or a thousand patents. I don't remember the
number but it was basically the entire Oracle patent treasure chest.

The judge whittled them down to under 10 and the USPTO with the help of a good
swift kick in the pants from Google got us to two. Well 1.5. Just imagine how
completely out of control this case would have been with say 10 patents never
mind the number Oracle was originally drag net fishing with.

Oracle dumped a truck load of manure in the court room. The judge is just doing
what he can to try and get some flowers to grow out of it.

[ Reply to This | # ]

Reports from the Oracle v. Google Trial - Day 16 ~pj - Updated 4Xs
Authored by: Rubberman on Tuesday, May 15 2012 @ 12:20 AM EDT
I am a professional software engineer with 30+ years
experience in the development of complex systems, including
interpreters and compilers. I even have a patent for adaptive
systems software as sole inventor. How one can expect a jury
to understand this cruft is beyond me! I understand what is
being discussed by the "expert" witnesses, but to think a
jury of non-expert people to understand the ramifications and
nuances here is just idiotic!

[ Reply to This | # ]

Precise distinction between numeric references and numeric digits used in symbolic references
Authored by: Anonymous on Tuesday, May 15 2012 @ 02:01 AM EDT
Dr. Mitchell said something which appears designed to confuse those present who don't know computing at a fine level of detail. I'm going to explain his answer so that people can see why it's inapplicable and a misdirection. Here is the context:

Oracle: Do Dalvik instructions contain symbolic references?
Dr. Mitchell: Yes.
Dr. Mitchell: What are they?
Dr. Mitchell: The field indexes.
Oracle: But those are numbers, does it matter?
Dr. Mitchell: Not at all, a number can be a symbolic reference.

I'm not addressing his first "Yes" because that is obviously false as a simple matter of fact, and his students are going to rip him apart for it which is punishment enough. Instead I want to address his last statement, which is less obviously wrong and may confuse someone.

He said "a number can be a symbolic reference". There is a problem with that statement, because it refers to two different things ambiguously, and only one of them is true, not the one that applies in the context of this case.

The word "number" can refer to native numeric fields such as integers, and it can also refer to non-native numeric fields typically encoded as strings. The process of transformation between these two forms obeys a standard collating sequence or ordering algorithm, which is a convention that allows (among other things) the unambiguous encoding and decoding of native numeric fields to and from strings. Central to this convention is that the numeric octets (digits) used in the string encoding have values and visible properties when printed which correspond directly to the native numbers which they represent in string form. Implied in this direct correspondence is a partial ordering of the values of the numeric octets (digits) in the string such that it maintains the monotonicity of the corresponding native numeric values.

In simpler language, the above means that native numeric values of 1, 2, 3 are encoded using octets that are conventionally printed as '1', '2', '3', and these octets have exactly the same ordering/monotonicity between them as the native numeric values to which they correspond. In other words, the octet '2' cannot denote the native numeric value 3, and when used in a decimal string, "22" always means (2*10)+2, it cannot mean (3*10)+3 or any other value.

This leads us directly to an unambiguous understanding about when "numbers" appearing in strings can create "symbolic references" and when they do not and cannot.

If a string contains only numeric octets and employs a known collating sequence so that the string can be decoded to a single native numeric value, then the string is ALWAYS a numeric reference even if it is in string form. It has a predefined value given by the chosen collating sequence plus the standard used for encoding numeric values in the required base. This value is fixed and requires no symbol resolution or lookup, only knowledge of the encoding algorithm and the octets of the string.

In contrast ...

If a string contains numeric octets but chooses not to employ any collating sequence information to given the string numeric meaning, or if the string contains non-numeric octets and it is not possible to directly decode this string into a single native numeric value without involving additional information, then the string CANNOT BE a numeric reference in string form because it has no built-in predefined value. Such a string can only be assigned a value by symbol resolution, a process which can assign to it ANY value whatsoever, because the octets of the string do not intrinsically encode that value.

So, Dr. Mitchell's statement that "a number can be a symbolic reference" is only true in a very limited and unusual circumstance which does not apply either in the patent, nor in Java, nor in Dalvik. None of these describe nor employ symbols with the peculiar characteristic that they employ numeric octets without numeric semantics and hence require symbolic resolution.

On top of that, none of the numeric references in Dalvik lack the numeric meaning that would demand treating them as a non-numeric symbol requiring symbol resolution, so his contention is not only wrong but also totally pointless for the task in hand.

Regards, anonymously.

[ Reply to This | # ]

Evidence -was- offered that the files were de minimus
Authored by: BitOBear on Tuesday, May 15 2012 @ 02:18 AM EDT
The court is, sadly, wrong about there being no contradictory evidence.

Since there are "166 APIs" listed in the jury instructions and
"each API" consists of hundreds of individual files, and the jury
instructions regarding "the work as a whole" it is obvious that two
fists full of files is de minimus to the list of all files in all the APIs of
the work as a whole.

Sure each file is a whole of a part, but as part of a whole each file is
statistically nill. It's like saying that my quotation of a -whole- -page- from
the collected congressional record for 2011 couldn't be rationally be considered
a minimal excerpt because it was, after all, a -whole- -page- (toh noes!).

There was -lots- of evidence about the -volume- of work in Android and the Java
Runtime Library and less that 20 files is way less than a fraction of a
percent.

That nobody -bothered- to point out the insignificance as a separate line item
doesn't mean that rational people listening to all that stuff wouldn't naturally
go "is -this- all you are talking about being taken from all -that-?"

[ Reply to This | # ]

Turing complete languages and numerical references
Authored by: Anonymous on Tuesday, May 15 2012 @ 03:21 AM EDT
From what I understand, in a Turing complete language (like
most, if not all computer languages) you can create any
effect and mimic any method you want.

So, the outcome of a numerical reference need not be using a
numerical reference to create the same effect.

IMANAL_TOO

[ Reply to This | # ]

Prior art in referencing?
Authored by: IMANAL_TOO on Tuesday, May 15 2012 @ 03:26 AM EDT
I haven't seen the prior art in different forms of references discussed very
much here. But it seems strange (even if it is not what Dalvik does) that
SUN/Oracle could have received a patent on a method of references, when there
ought to be loads of prior art here.

What makes their case special they think?




---
______
IMANAL


.

[ Reply to This | # ]

BS&F prove patent irrelevant to both Android and Java
Authored by: BitOBear on Tuesday, May 15 2012 @ 03:59 AM EDT
=== transcript quote begin ===

Oracle: So the operands are a fixed length in both a dex file and a .class
file?

August: I believe so.

Oracle: So it would also be true for a Java bytecode instruction? Is it your
testimony that there are symbolic references in the instruction stream output by
the javac compiler?

August: I believe it does not output symbolic references.

Oracle: So Java doesn’t do this either?
(etc.)

=== transcript quote end ===

Didn't oracle just prove that the patent in suit isn't part of Android -AND- it
also isn't part of Java?

Isn't equal inapplicability the opposite of infringement?

In short, we have just established that this patent is as relevant to
"Google infringing on Sun/Oracle's Java" as would be a patent on
growing watermelon in a desert?

Shame August didn't jump on that and answer, "Why yes, now that you mention
it, this patent has nothing to do Java or Android at all."

[ Reply to This | # ]

Oracle's proposition
Authored by: Ian Al on Tuesday, May 15 2012 @ 04:04 AM EDT
It all reminds me of an old joke whereby the old spinster is told that she could
not possibly have been offended because she could not see the bedroom window
from where she claimed she had.

She replied that it was easy if she climbed on to the wardrobe and used her
binoculars.

'Speculation and innuendo, they're sorts of evidence, aren't they?'

Mitchell is asking to stretch the claim construction decision of the judge
around reinterpreted explanations of how Dalvik works to fit the words in the
patent claims.

Worse, he is saying that re-using code blocks that are also used in the Dalvik
run-time engine is the equivalent of having the run-time engine running.

'Oracle: Dexopt processes the file while the Dalvik VM is running, true?'

[Auto analogy: getting earwax out of your ear using the ignition key is the
equivalent of running the engine whilst filling the gas tank].

Meanwhile, in the 'fun' universe, the coder complains that the patent is
hopeless in explaining how this highly efficient static indexing system works in
the invention.

The more the Judge's Rule 50 decision is explained to me the more in error it
seems to be. webster explained to me that any confusion of the jury because the
jury instruction did not point out that decompilation can be copyright
infringement was down to the judge.

Now he allows Mitchell's assertion that the test files are 'very important' to
outweigh the uncontested fact that Google did not know the test files were in
the Android development materials.

In the judge's order he says 'Professor Mitchell testified that using the copied
files even as test files would have been significant use'. The judge knew the
uncontested fact that no significant use was made of the files and also accepted
Mitchell's legal opinion on copyright law.

Finally, I thought that Google stipulated that the files were copied. Oracle
proceeded to put testimony in front of the jury to 'prove' the stipulated fact.
Then they asserted un-stipulated and unproven facts that conflict with the
grounding of the stipulation.

I can see that Oracle's lawyers will never have any fact stipulated by the other
side ever again. They will have to fight every step of the way and appeal every
win because of what they have done here and in SCO.

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

[ Reply to This | # ]

And the prize for conflation and misrepresenttaion goes to
Authored by: Anonymous on Tuesday, May 15 2012 @ 04:11 AM EDT
Oracle: And dexopt loads the dex file into the Dalvik VM?

August: No. Dexopt processes the file that is placed on the device.

Oracle: Dexopt processes the file while the Dalvik VM is running, true?

August: Not for the same program.

Oracle: That’s not what I asked. Is the Dalvik VM running?

August: Sometimes.

Yes... A Dalvik VM is running somewhere in the world, but of no relevance or significance to the argument.

Given that Android runs a VM for every application, it's possible for other VMs to be running, but Oracle know full well that they are unrelated to the task or the optimisation.

This kind of lawyer nonsense (which if anyone else did it would be considered lying, rather than being good at one's job) really makes me sick sometimes.

The remark in bold is the true part that Oracle are trying to cover up. Hopefully the jury will get this

If they get away with this stuff, I'm going to stop working with software, the lawyers have killed it for me. I am truly disgusted.

[ Reply to This | # ]

Offset vs. Index -- A Show Down Showcase.
Authored by: BitOBear on Tuesday, May 15 2012 @ 04:48 AM EDT
So we see offset and index, the computer terms of art, being abused before our
very eyes. This latest in the BitOBear Colloquium of computer science will
address this in, hopefully, big friendly letters.

An offset is a -distance-, it is how far some thing is from something else.

An index is a position, it is the absolute location within a predictable
sequence.

Again, ignoring computers for a bit...

If I have a railroad, and I have a train, and I am on the train with you, and I
tell you to get off in two stops, what happens?

Well I have given you an -relative- index, because we are in the train at a
stop, the zeroth-stop is here, and it is at offset zero. If the distance between
stops zero and one is 100 miles, and the distance between stops one and two is
50 miles, there is an equivalence between me telling you to get off in two stops
with the indistinguishable instruction to get off when the train stops in 150
miles.

Telling you to go two stops from here is directing you by index in this usage.

Telling you to go 150 miles from here is directing you by offset in this usage.

Now if we happen to be in the very first stop of a linear railroad, and we were
counting like humans, stop number one would be at offset zero miles, and stop
number two would be at offset 100 miles, and stop number three would be at 150
miles.

Computers hate that whole counting-from-one thing because computers -always-
turn indexes into offsets as a side effect of how they work at the electrical
level.

So counting as a computer counts, the very first stop is stop "zero"
because you have to do -nothing- to get from the first station to the first
station and the first station is zero miles from the first station. So the
action of turning the station number into the distance down the track is free
for zero. This is good because anything times zero is zero. So this lets things
just work our right later. (see below).

So computers -can- deal with having the distance from stop zero to stop one be
twice as long as the distance from stop one to stop two. They -can- deal. But it
sucks. If -all- the stops are the same distance apart, say 50 miles in this
example, then they can do things like find out how any two stops are from each
other by doing math instead of tracing along a map. The distance between stops
four and nine is 250 miles because (9 - 4) * 50 is simple math.

So... lets return to inside the computer.

If I make a table of things in some location "Stuff", I can ask for
the third thing in stuff by saying "Stuff[2]". (remember the first
thing is in Stuff[0] because you only have to "skip over" zero things
to get to the first one).

Now the computer, electrically, doesn't -care- why you want Stuff[2] and it
doesn't even know that there is a pile of Stuff to begin with let alone that you
want the third thing in that pile. It is electrically looking to fetch some
number of data from some electrical location. So the compiler has turned
"Stuff[7]" into an instruction like "fetch
size_of_one_thing_in_bites from (address_where_Stuff_Starts *
size_of_one_thing_in_bytes * 7)"

That's the kind of math that the electrical mechanism called "a
computer" can do.

Remember that the various VMs are -not- computers, they are programs running on
computers. The VM opcode 51 01 is read by the program (the VM) and it already
knows where the Stuff[] is, and it now knows that we want to skip over 01 of the
Stuff to get the second one VIA PURE MATH. There was no "lookup" so
this isn't a "symbolic" anything, it's a concrete numeric math-problem
used to find "something". That -something- can turn out to be a
symbolic reference sure enough, but it could be the address of a string, or a
floating point number, or anything else.

But Wait! computers don't like it when their things are different sizes because
they would be different amounts apart and the math would blow. That's why the
table of stuff in the VM is a list of numbers (all the numbers are the same
_size_) that lead off to where the real things are. So the table of Stuff[] is
still just full of numbers, those numbers being the "real" address of
where the real data lies.

But none of this is "symbolic" references. It's more me telling you
(winding back to the original analogy) and telling you not to go to station 4
but to look on the sign board and go to the station listed on the fourth line.
Now we can have express trains that go different distances between stops but
still do the math in a computer friendly way. There were indexes and offsets
with respect to the sign, and that sign may also tell you how far away each
station is. So now we can also get the distance you will travel by looking at
the sign instead of running down the track.

See, _tables_ make everything faster when you can pack together a lot of things
so that they take up a predictable amount of space each.

ASIDE:

So indeed, this patent, as written doesn't apply to Android, nor does it apply
to Java as near as I can tell.

I am not surprised. I was forced to write a patent application by a former
employer once. After I wrote it, the patent lawyer re-encoded it legal bull. I
was sure, reading the result of the lawyer's work product, that our own product
was not covered by the patent as written. I said that to my boss -and- the
lawyer and I was informed that I simply didn't understand the patent process.

I still know I don't, I cannot stoop that low.

[ Reply to This | # ]

Revised list of Paided Experts
Authored by: Ian Al on Tuesday, May 15 2012 @ 05:11 AM EDT
Florian Müller
John Mitchell

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

[ Reply to This | # ]

On Weasel Words: What us programmers hear
Authored by: BitOBear on Tuesday, May 15 2012 @ 07:01 AM EDT
So, since car analogies are seemingly mandatory in explaining computer science,
here is what we programmers hear when we listen to these two experts.

Analogy:

I have a car, it has no engine just now, and no license plate or tabs. I place
it on a tow-truck and drive it to the mechanic on a Monday to have the
suspension re-tooled. On Tuesday I take it back home on my tow-truck. On
Wednesday I take it in to have the body repainted. On Thursday I bring it home.
On Friday I take it to an engine shop.

When I go to pick it up on Monday, still and again with the tow-truck there are
cops waiting for me. They claim that "I have driving my car around all
week" and no matter how much I try to explain that i -was- "driving my
unlicensed car around" I was doing so with a tow-tuck not under its own
power.

So Dalvic -cannot- have "symbolic references" in "any
instruction", and the patent covers "symbolic references in
instructions". These are facts. Just as the law requires my car to have a
valid license and registration/tabs, but when the car is being "driven on a
highway" using a tow-truck (in the sense that I can "drive a child to
soccer practice" by placing them in a minivan) is -not- a valid application
of those words to that circumstance.

So...

The Oracle expert is -insisting- that Dalvic is driving the car on the highway.

The Google expert is -insisting- that Dalvic, possessing a car without an engine
installed, can not "be driving" in any sense the law might apply
within.

The latter is the more-true statement, but the former has truthiness on its side
for sounding reasonable and being a shorter, more direct sentence that was
presented first.

But the assertion that the car was "driven all that week" would be
pure "weasel words"

http://en.wikipedia.org/wiki/Weasel_word

This should not be a valid legal strategy, but neither the court nor the jury is
a programmer normally skilled in the art, so it is unlikely to understand the
deception.

[ Reply to This | # ]

Can someone please explain the test files to me?
Authored by: rsteinmetz70112 on Tuesday, May 15 2012 @ 09:37 AM EDT
What are the test files used for?

Where did they come from?


Are they a part of OpenJDK?

---
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 | # ]

Someone with an account submit this to Slashdot !
Authored by: Anonymous on Tuesday, May 15 2012 @ 09:38 AM EDT
This incident is just begging for a Slashdot story. "Stanford CS Prof
Testifies Under Oath That Numeric Indexes Are Symbolic References."

Maybe nothing will happen to him in a court of law, but Prof. Mitchell
certainly deserves to be tarred-and-feathered in the court of public opinion
for this. His students deserve to know too, and at least some of em must
read Slashdot!

[ Reply to This | # ]

Dalvic vs Dexopt, how can one body of code be two different programs.
Authored by: BitOBear on Tuesday, May 15 2012 @ 01:24 PM EDT
So some of you may be wondering how the apparently single body of code which
makes up the Dalvic VM (dynamic runtime) and the Dexopt installation optimizer
(static linker) be different programs if its the same code...?

This is a feature of Java and the way it handles classes.

So again, for a moment, lets forget computers...

I have a strange machine. It is table-shaped and it is used to transform wood.
Let's call it a "ripper". But in truth its a table and a bunch of
guides and a motor fast-and-strong. If I put one blade in its bits I can make
cut grooves, if I put another blade in its bits I can plane a surface smooth.

I have another machine. It can, with the push of a button, go from joining
fabric sections together, to decorating a flat expanse of fabric with letters
and symbols. It's called a sewing machine.

So we know that machines can be inherently multi-purpose and be
"modal" in that they can be operated in one of some number of unique
modes.

Now back inside computers.

Java "programs" are stored in jar files, which are zip files with an
index, which are indistinguishable from directories full of separate files (for
all reasonable purposes here). The code of a program does -nothing- until
something invokes that code. Once invoked in the abstract, some of the code will
be used and some will not based on things like how the various "if"
and "when" constructs are found to be true and false.

By putting more than one class in a jar with a member that has a signature
reading "public static main()", we can invoke the "program"
by starting with different class.main() entry points and be thus rewarded by
radically different behaviors from the same body of code.

If you find this idea confusing, you shouldn't, you use it all the time if you
use Microsoft Office, or LibreOffice, or OpenOffice. You call it by
"exce" or "calc" or whatever and it presents a spreadsheet.
You use "word" or "write" and it presents a word processor.
But in truth these invocations are immaterial since you can go to the
file->new menu and create a word processor instance and document by selecting
file->new->text document, even if you do so from within the spreadsheet
face.

The Ada language even defined the entire experience in terms of a
"theoretical machine" that you add all your code to during compile.
This "machine" was basically in a perpetual quantum superposition.
When you wanted to "produce" a program, you would tell the machine to
disgorge the relevant code from the whole machine to leave you with a single
actual path of execution re-expressed into a runable executable.

hua?

For any body of code, if it has "more than one program it it" each
element of that body of code can be classified as exactly one of exactly three
things with respect to any program it contains:

(1) code that is unique to the program in question.
(2) code that is common to the program in question and at least one other
program in the system.
(3) code that can/will never be invoked by the program in question.

This is true also of any compilation and runtime environment such as the shared
libraries and programs on your linux or windows computer.

So if the body of code only has one program in it, its all item 1.

Dalvic VM and Dexopt collectively have a whole lot of item (2), but the part
that rewrites the code at install time is item (1) for Dexopt, and item (3) for
the Dalvic VM. Just as the part that "runs the application" is item
(3) for Dexopt and item (1) for the Dalvic VM.

Now Android -could- have copied all of the item (2) code onto the phones
-twice-, once for Dalvic, and onece for Dexopt. That would have been a huge
waste of space and memory and processing power within something small and
lightweight such as, say, a smart phone. So Google et al left it all in the one
pile and invoke it in the composite.

This commonality of code doesn't make the two programs into one program.

Oracle is trying to say that since it is all in one pile it is all one thing.
Were such analogies true it would make by dirty laundry much easier to deal with
because I could clean it all by washing one shirt... 8-)

[ 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 )