|
Authored by: s65_sean on Saturday, April 21 2012 @ 10:25 AM EDT |
Mark, I think you are confused. You say:
So the question is, given
that the Java programming language is licensed under GPLv2, are the APIs and
associated class libraries necessary to make programs run in the Java language
"associated interface definition files?" If so, one could argue that those 37
APIs are a part of the "work as a whole" (the Java programming language) and,
thus, also subject to the GPLv2. Interesting.
The license that you
were quoting before that statement appears to be a license for a software
program, as it talks about "the program as a whole". The java programming
language is not a software program, it is the language that you use to write
programs. Perhaps the license you are quoting from is for a java compiler or for
a java environment implementation, but it certainly should not be for the java
programming language, otherwise the stipulation that was made in court this week
that hte java programming language is free to use by anyone would make no sense.[ Reply to This | # ]
|
|
Authored by: Anonymous on Saturday, April 21 2012 @ 10:26 AM EDT |
The Java API's have been released under the GPL as part of OpenJDK. See
http://openjdk.java.net/legal/gplv2+ce.html . However, for Goggle or anyone
else to take advantage of this, any version they derive from the OpenJDK would
have to be release under the GPL. In other words, Google would have to license
Android under the GPL, and all phone manufacturers would have to release the
code to the phones under the GPL. Google chose not to use a GPL license or GPL
derived code for Android because they did not believe the platform would be
adopted by the phone manufacturers if they had to release their derivative code
under the GPL.
But the bottom line is that anyone can release a Java environment under the GPL
can claim the benefit of the OpenJDK license, but if their Java environment is
not released under the GPL, the OpenJDK license doesn't help them.[ Reply to This | # ]
|
|
Authored by: SilverWave on Saturday, April 21 2012 @ 10:27 AM EDT |
:-)
---
RMS: The 4 Freedoms
0 run the program for any purpose
1 study the source code and change it
2 make copies and distribute them
3 publish modified versions
[ Reply to This | # ]
|
|
Authored by: SilverWave on Saturday, April 21 2012 @ 10:28 AM EDT |
:-D
---
RMS: The 4 Freedoms
0 run the program for any purpose
1 study the source code and change it
2 make copies and distribute them
3 publish modified versions
[ Reply to This | # ]
|
|
Authored by: SilverWave on Saturday, April 21 2012 @ 10:29 AM EDT |
#-#
---
RMS: The 4 Freedoms
0 run the program for any purpose
1 study the source code and change it
2 make copies and distribute them
3 publish modified versions
[ Reply to This | # ]
|
|
Authored by: Anonymous on Saturday, April 21 2012 @ 11:07 AM EDT |
That part of the license just means, that if you take OpenJDK under the GPL
license and want to extract *a part* of it and give away that part, you still
have to give the source code for the work as a whole (i.e. the entire OpenJDK,
not just the little piece you are giving away as part of your program).
It doesn't apply to Google anyway, because they didn't use any OpenJDK code.[ Reply to This | # ]
|
|
Authored by: Anonymous on Saturday, April 21 2012 @ 11:17 AM EDT |
2. With respect to what segment of the “work” can stand alone
within the meaning of Hustler v. Moral, 796 F.2d 1148, 1155 (9th Cir. 1986), the
Court wishes to know whether the implementation of the 37 API packages inherit,
call upon, invoke, or incorporate any method, field, or class outside the
37.
That's a tough one for Oracle. Again it demonstrates
Judge Alsup's superb technical understanding. The 2nd part leaves Oracle no
wiggle room, no hand-waving. It's a completely objective technical question and
I hope Google's lawyers recruit some competent techies to present that
dependency graph in an impressive manner.
While I have not checked it
myself, my feeling is that depending on the dependencies you look at, almost all
of the 37 APIs and in fact much more than that is interconnected. In particular,
and that's the major issue I see for Oracle here, the dependency graph will show
that you cannot cleanly separate what Oracle contends is the "Java language"
from the "Java APIs". For instance java.lang.String (conceded by Oracle to be
part of the freely usable "Java language") has a constructor that throws
java.io.UnsupportedEncodingException which puts us straight into the "java.io"
package which as I understand it, Oracle claims is not free. And the court not
only asks about the declarations but also the implementation ("call upon",
"invoke") and when you go down to that level, you find even more
interconnectness. Here are the imports from the implementation of
java.lang.String from OpenJDK 6:
import
java.io.ObjectStreamClass;
import java.io.ObjectStreamField;
import
java.io.UnsupportedEncodingException;
import
java.nio.charset.Charset;
import java.util.ArrayList;
import
java.util.Arrays;
import java.util.Comparator;
import
java.util.Formatter;
import java.util.Locale;
import
java.util.regex.Matcher;
import java.util.regex.Pattern;
import
java.util.regex.PatternSyntaxException;
I'm quite sure that
the above java.util.* classes are on Oracle's "non-free" list. But how are they
going to explain that you are free to use the String class as part of the Java
language, if that class cannot be implemented without using non-free classes?[ Reply to This | # ]
|
|
Authored by: calris74 on Saturday, April 21 2012 @ 11:28 AM EDT |
In C and C++, the API definitions are in a bunch of header
files and you
program needs to include the header before it
uses the API
But the
library is nowhere to be seen when you write the
code The compiler only needs
the headers to know how the API
should be called (function name, number and
type of
arguments etc)
The library needs to be available when you run
the program.
The dynamic loader/linker will load the library and do all
sorts
of behind the scenes stuff to make sure you program
can call functions in the
library.
But, the library does not need to be the the same one as the
one written by whoever wrote the header files - so long as
the implementation
exactly matches the definition. Wine is a
perfect example - it is a collection
of independently
written libraries which implement the Windows
APIs
Now header files have never been copyrighted (or the
copyright
never enforced) as to do so would mean nobody else
could write programs using
your API.
But Java is different - There are no headers. The API
definition is in the Java library (.jar) files themselves.
So now you have a
file with a mix of API definition and API
implementation which (at least part)
is definitely covered
by copyright...[ Reply to This | # ]
|
|
Authored by: Anonymous on Saturday, April 21 2012 @ 11:48 AM EDT |
It seems to me that Oracle keeps conflating "the ideas that constitute
APIs" with "the documentation that constitutes fixed descriptions of
those ideas".
You can copyright Harry Potter, the movie, and the corresponding script, and
even the sentence, "a child awakens to their magic powers, trains, and
defeats a world-threatening evil", but the idea behind all three remains
free. APIs as "the essential plot points of software" leans closer to
a literal description than a metaphor.[ Reply to This | # ]
|
|
Authored by: Anonymous on Saturday, April 21 2012 @ 12:01 PM EDT |
1. Does a programmer install the javac compiler and the rest of the Java
Development Kit on a PC?
2. Does the programmer add some Android/Dalvik/Harmony-specific
classes to the classpath?
3. Does the programmer write x.java source files?
4. Does the programmer compile them with the standard Java compiler
javac?
5. Does the programmer then use some Android/Dalvik-specific program to
do something with the bytecodes in the x.class files written by the
compiler?[ Reply to This | # ]
|
|
Authored by: vadim on Saturday, April 21 2012 @ 01:38 PM EDT |
Assuming that:
1) Current law allows reverse engineering of the software
2) If API is copyrightable it means that any use of the API requires
permission of the copyright holder
By virtue of 1) i can reimplement java library to ensure that java apps can
run on my platform
But by virtue of 2) i can't do it if copyright holder doesn't allow it.
It means that assumption 2 contradicts assumption 1 which is current law. Ergo
- assumption 2 is incorrect[ Reply to This | # ]
|
|
Authored by: Anonymous on Saturday, April 21 2012 @ 02:44 PM EDT |
Easy: This is already in copyright law and what is purported to protect software
copying.
“class libraries” are an "expression of the source code"
This goes to the whole tangible medium thing.
ExcellentGame(tm) is distributed on Cassette tape.
Joe takes a binary copy of the tape, and records it onto a floppy disk.
Joe is a flagrant copyright violator, he has copied the expression in the
tangible medium.
Bob, takes a copy of Joes floppy disk, and transfers it on tape. Whoops, wrong
tangible medium, yet Bob clearly has a copy of ExcellentGame(tm) and is having
fun with it without paying.
Easily fixed. The binary is a (tangible) expression of the source code.
The "Class Libraries" are an expression of the "Java API source
code"
The source code is protected, the "Class Libraries" are protected, the
"English language Book" describing the libraries (API Specification)
is protected.
The facts about the class libraries, which are contained in all three items are
not.
Game over.
Done.
[ Reply to This | # ]
|
|
Authored by: Ian Al on Saturday, April 21 2012 @ 03:11 PM EDT |
The Java API Specification is a manual and not source code for a program. The
GPL refers throughout to a copyright program. You cannot derive a program from a
manual. Thus the GPL does not apply to the Specification. There is another
licence that applies to documentation. The documentation licence explains
document copying, modification and redistribution.
As with any book about making things, the names, ideas and concepts in the
Specification book can be used by programmers to write libraries for the use of
Java application programmers.
A clever programmer can even replace all of the Sun libraries with their own
version and the application programmer can use them in just the same way as the
Sun library originals. For this to work, they have to use the same function
names and use that name to locate the function packaged in the same way as the
original Sun library packages. This may be where the valuable SSO comes into
play. However, knowing that the function foobar must be placed in package foo
for compatibility does not use much of the SSO. How much SSO is lots?
The APIs in Sun Java, Harmony and OpenJDK are not interfaces. They are source
code and byte code (binaries) for libraries of functions that can be used with
Java.
There are no interfaces in software. The interfaces are abstract concepts
documented in manuals to help programmers write down what is necessary to make
available functions in libraries or other programs. All there is is functional
program code that is either provided by the programmer of an application or
provided by libraries or other programs including operating system programs.
APIs are a higher level way of getting at functions. An API is the use of a name
in the syntax of a computer language to match to the same name in the library
thus identifying the function code to be used.
When programmers were real men, they wrote their program code, put it directly
into the memory and arranged for any libraries of functions to be loaded
somewhere else in memory. The individual functions in the library were found
using the number of bytes offset from the start in memory of the library at
which the specific function code could be found.
Some microprocessor instruction sets made offset jumps very easy. Some did not.
If the worst came to the worst, one could look up the offset in the library
manual, add it to the base address of the library and make the processor start
executing the code at the new location.
JMP [Address]
Now those operating system monsters and hard drive file system loonies have got
on the scene, a programmers memory is not his own. He is forced by these malign
monsters to use ABIs and APIs and to 'jolly well put up with being loaded where
we want you loaded'. They won't even tell you where the libraries are kept in
memory, any more.
The programmer has to look up in a book how to get access to system or library
functions. The Java Api Specification is just such a book... compilation of
books... list of compilation of compilations of books.
The compiler and the library code just don't care. They look at function names
in the programmers code and pick out the function code in the library identified
by the name.
Then they look in specific places in the programmers code for any parameter data
to be used with the library code. The compiler then plops library and program
code (in byte-code form) into the class file as a single logical set of
instructions.
As far as the compiler and library are concerned, you can use the Specification
to resolve the offset in a kitchen table leg.
---
Regards
Ian Al
Software Patents: It's the disclosed functions in the patent, stupid![ Reply to This | # ]
|
|
Authored by: Anonymous on Saturday, April 21 2012 @ 03:15 PM EDT |
'So the question is, given that the Java programming language is licensed under
GPLv2, are the APIs and associated class libraries necessary to make programs
run in the Java language "associated interface definition files?" If
so, one could argue that those 37 APIs are a part of the "work as a
whole" (the Java programming language) and, thus, also subject to the
GPLv2. Interesting.'
AFAIK this case is about Java 5 which was never released under the GPL. So I
doubt this argument is relevant - even if Java 6 (which was) and 5 are
substantially similar? 5 is not a derivative of 6 for simple causality reasons,
lol
IANAL, etc.[ Reply to This | # ]
|
|
Authored by: Anonymous on Sunday, April 22 2012 @ 12:30 AM EDT |
I have been reading Groklaw since the beginning. This is my
first post. I am
completely missing Mark's point:
So the question is, given that the
Java
programming language is licensed under GPLv2, are the APIs
and associated
class libraries necessary to make programs
run in the Java language "associated
interface definition
files?" If so, one could argue that those 37 APIs are a
part
of the "work as a whole" (the Java programming language)
and, thus, also
subject to the GPLv2. Interesting.
Yes, it is clear that the
JRE including the APIs is
licensed
under the GPLv2. This is not news. But
what relevance does
this have to Oracle-Google ? I don't see how this can be
used to either attack or defend, either Oracle or Google ? [ Reply to This | # ]
|
|
Authored by: RMAC9.5 on Monday, April 23 2012 @ 11:28 AM EDT |
It is a specific instance of the Java language just like a poem or a story is a
specific instance of what ever language it is written in.[ Reply to This | # ]
|
|
|
|
|