By now everyone is rolling their eyes when I bring this up, this thing we're
calling java'a API is not really an API, because java is a language and
standard
set of libraries and not
an application. While the ideas behind
java, e.g., the formal grammar
and specific keywords and concepts of how a
programmer interacts with the
computer are not protectable by copyright, the
expression of these things, as in
the
published specification and
documentation, is. The documentation
reveals a
structure that is a
creative work, in that choices were made. There was no
inherent reason why
Gosling and fellows had 166 packages and not 165 or 167.
Google looked and
copied the documentation that Apache had which was a
copy of Sun's
documentation, to the depth of the names of the packages,
classes, and methods.
Google did not take a little from this and a little from
that, but grabbed in
their entirety certain packages. Google didn't have to do
this: there was no
interoperability that was necessary. It was a shortcut in order
to get to
market faster. We all understand that when we discuss
copyright law, we
have to distinguish between recordings, choreography,
books, plays,
dictionaries, music composition,
computer programs, etc., and, indeed, a
computer language is not a program
or application, which do have good case law.
(The
programs connected to a particular language are the parser, compiler or
interpreter.) Most
languages are defined in academia
or have been contributed
to standards bodies by their creators (probably
after they realized that there
was no commercial advantage to be the solitary
source. Also, the value is in
the compiler, interpreter or runtime.) There are a
few languages which were
made by a
vendor for strategic purposes and java is one: it never was submitted
to a
standards body. So here was a case where discrete parts of a
vendor-controlled
language were copied by another commercial entity. This is
why this case is
unusual and the Judge asks "Can a language by
copyrighted?" Java is
also a standard library. As the Android standard
library is very different, is it a
copy of
Oracle's java? There are
similarities (semi-colons show the end of statements,
new is the keyword that
causes an Object to be instantiated) that are not
protectable. But, if one
looked at a listing akin to O'Reilly's Java in a Nutshell of
the 37 packages
for either Oracle or Google's java and it'd look the same. To
concentrated to
be casual, too exact to be an accident. There was copying of
something
written.
I've decided that I believe that what Google copied (from
Harmony),
though significant, was not enough to matter. I liken it to someone
writing a
dictionary, by taking Webster's and writing down the words that are
defined and
then writing totally original definitions (or definitions informed
by original
research in usage and history.) The important part was not
copied.
Now that I know the Judge writes programs, I think he understands
that the
law on applications doesn't quite fit computer languages owned by a
vendor,
such as java. I now think it is more likely that he will understand
that Google
looked
up the documentation and then wrote their own work, which
is the process of
programming: look up what we don't remember and use. Before
we had
autoboxing in the java
language, I had use for a dynamic Object that
contained primitive int values. I
looked at the List language to pick method
names that any one else looking at
my code
would expect given the
functionality I was implementing. For example, the
count of values in the
IntList was size(). I may have toyed with implementing the
List interface. I
did call it
an IntList. As I've
said before, writing a program is taking a
language and its
library and extending it so as to facilitate the applications
that solve my
problems. Or, to speak in mathematical terms, take the axioms and
theorems
provided by the language, library, and frameworks, and prove new
theorems.
When I'm using functional programming,
that's very close to what I'm
doing: writing a small unit that does one thing
correctly without side effects
and then compose the units. Speaking
of
dynamic, Jacobs was using it
correctly, just not
in the same context as the patent. He was saying it was
dynamic because the
byte code writer did different things when placed on
different hardware and I
can see the word making sense there. But, the patent
was about things that
happened at run-time regarding filling in actual value to
dereference symbols
(which contained no information about actual memory
location) left in the byte
code at compilation. The testimony from both sides
seemed consistent on
proving the fact that Google was doing things
statically. [ Reply to This | Parent | # ]
|
