First of all, who is arguing with you that copyright protection for apis is a
good idea? The discussion is whether the documentation of the api can be
protected against the way Google allegedly used them. There are quite a few
things the law allows that I think are bad ideas and there are some good ideas
that the law hasn't caught up with yet. But, Oracle, Google, Judge Alsup and
the
jury have to work with what the law is and not what it should
be. Next,
if you
don't like the way Oracle's package is implemented, you
are always free to
implement your own packages. Indeed, that's what writing an
application is:
extending the existing java library in ways that implement your
algorithms and
solve your problem. I,
personally, have my own code for date
parsing and arithmetic. I needed it for a
time clock application, in support of
a WorkWeek class I wrote, where the week
began on Saturday. My biggest
issue
with java.util.Calendar? java.util.Calendar.JANUARY was 0 and I preferred
January to be the first month, not zeroth. Pretty petty, I know.
That
said, you will find
that you cannot rewrite java.* or sun.* packages. This is
controlled by the
license you
agreed to when you downloaded the java sdk from
Oracle. If your
criticism of that java.math.trajectory package (wouldn't
it be more properly
found in a physics package?) was an honest-to-gosh
identification of a bug, I
suspect they'd be very pleased if you filed the bug
report and would fix their
class at the next update. If you want to change the
language, that requires you
filing a JSR with the JCP. One group of engineers,
feeling that java's support for
XML was inadequate (it was non-existent)
started a project called JDOM and
provided their source and binaries in the
package org.jdom.*. Members of the
JCP liked their work, and submitted it as a
JSR which was approved. Before it
became a part of the language and even after,
I use the org.jdom package,
downloaded from www.jdom.org website, for
my xml
processing, as per the license they give me for their copyrighted
code.
Now the JCP receives
many suggestions as to how the language
should change. The first thing that
happens after someone creates a language is
that some user wants to change it.
Change requests are generally of two types:
1) importation of a favored bit of
semantics or syntax from another language,
or 2) Some library or syntax which
aids in solving specialized problems.
Because a language is usually closely tied
to a program that compiles or
interprets it, and let's call that the runtime, a
change
to the language often
implies a change to the runtime. This could explain why
the JCP seems
lubricated with molasses. In fairness, java is widely adopted
and an important
strategic language to Oracle, so a conservative approach may
be smart because
an unforeseen consequence due to a change could impact
millions of
people. Relating my days with the j lang, the first standard
collector
object I was taught to use was a Vector and one inspected and
transformed the
elements of the Vector
through an Enumerator object. Sun realized that these
were bad names and that
Vector objects had poor performance because methods
were synchronized,
meaning only one object could have access at a time. Sun
created a List
interface with a few different concrete implementations, such as
ArrayList.
They created an Iterator interface because Enumerator was really,
truly, and
widely recognized as the wrong name for what it did. As Sun put in
List and
Iterator, it left in Vector and Enumerator. Eliminating them would
have broken a
lot of
code then, and I suspect now, though it's been over ten
years. Back
then, I had a lot of code that had:
Enumerator enum =
vector.elements(); A version or two later, Sun again
changed java and put
in proper enumerators, which were a special type of class
and labelled with the
newly added keyword: enum. As a result, all my
Enumerator enum code stopped
compiling. Oh well. I was happy for the change,
despite the
inconvenience. The need for real enumerators came up
back in the 90s, but
I believe it was C#'s rollout which led to this and most of
the
programmer-friendly changes to java. I still come back to my
question
whenever I see people talk about how what Oracle is claiming
interferes with
their way to fix java. Why waste time? I use java a lot, but only
after
evaluating if I could get away with using the languages I like better. Other
people, such as Martin Odersky and Bill Hickey, had some real problems with
java, but liked the jvm, so they wrote Scala and Clojure. Guy Steele, author of
the java specification books and an important person in documenting and
bringing forth Common Lisp and Scheme, was at Sun and presumably now
Oracle
working on a language called Fortress. The first motive was because java
is not
good enough with the high precision arithmetic that your
java.math.trajectory
package might need. As they progressed, I think they
decided to make Fortress
more functional than java is. Or, use java to
create
your own language:
define the grammar, add keywords and symbols, using
java, write a
parser and
class loader and then let javac compile statements to byte code and
let the jvm
execute. You have full control of your semantics and syntax and,
no, no
one,
not even Oracle, will come after you for copying java. Distribute the jar that
parses statements in your language and if it solves enough problems for
enough
people, you will be celebrated. And then a day later, someone will ask if
you
could change your language and add this or alter that. [ Reply to This | Parent | # ]
|