It's like asking a dozen parakeets which of the two nuclear physicist in the room is right about string theory. I fail to see how their opinion can be relevant.
Programming isn't nuclear physics and juries aren't parakeets. And you're not asking juries broad questions like "who is right about string theory?" you're asking them very pointed questions like "did X present sufficient evidence to show that Y is true?" Even in a technical trial, you're not asking the jury technical questions like whether some code implements quick-sort or bubble sort. The law by and large doesn't deal in those sorts of questions and as a result those questions don't get posed to the jury.
"B. Has Google proven that its use of Oracle’s Java documentation constituted “fair use”?"
The judge will explain in detail what "fair use" means according to the law. The factors of fair use are something like this:
1) the purpose and character of the use, including whether such use is of a commercial nature or is for nonprofit educational purposes;
2) the nature of the copyrighted work;
3) the amount and substantiality of the portion used in relation to the copyrighted work as a whole; and
4) the effect of the use upon the potential market for or value of the copyrighted work.
An average person can evaluate whether Google's use of Oracle's documentation was commercial or educational. They can be made to understand the difference between documentation and actual code that makes a product work. They can be made to understand the difference between a few lines of code and a program containing millions of lines. They can hear evidence from experts about the potential impact of the use and decide who they find more credible.
It's not like on TV where there is a "guilty/non-guilty" verdict. The juries are asked very specific things that are expected to be within the range of comprehension of an ordinary person.
In this specific case, it's hard to imagine an average layperson being able to grasp such concepts after a reasonable amount of instruction by experts and the judge.
Let's use the Java interface construct as an example. It's expressed as code, but is it really just code? Isn't it really a spec other classes must implement in order to become valid Java code, expressed in code for the benefit of the compiler?
I consider my own unit tests as part of the documentation of the systems I deliver. There is little question as to whether the doctests are documentation, but testing them makes them execute. What are they then?
What if my code, during startup, reads UML files and compiles them to behavior that becomes part of the system during execution?
And my analogy works both ways - the opinion of a dozen theoretical physicists on birdseeds is equally relevant.
> In this specific case, it's hard to imagine an average layperson being able to grasp such concepts after a reasonable amount of instruction by experts and the judge.
Let's use the Java interface construct as an example. It's expressed as code, but is it really just code? Isn't it really a spec other classes must implement in order to become valid Java code, expressed in code for the benefit of the compiler?
1) The jury doesn't decide whether Java interfaces are protectable code versus unprotectable specifications. That's a legal determination for a judge. The judge deals in these sorts of general or philosophical principles. The jury deals in specific facts.
2) Technical distinctions aren't necessarily legally operative distinctions. The law tends to be based on things that are within typical peoples' experience.
3) You have days of peoples' undivided attention to explain things to a jury.
So in this example, the judge would be the one to decide whether Java interfaces, in principle, were protectable or not. The jury would decide things like the fact of whether Google copied Oracle's interfaces. Someone at Google might testify that they never saw Oracle's interfaces, and came up with them independently. The jury will decide whether they believe his story. They'll be shown code. They don't have to understand how it works to know whether the same variable names, etc, are being used.
