decoration decoration

When you want to know more...
For layout only
Site Map
About Groklaw
Legal Research
ApplevSamsung p.2
Cast: Lawyers
Comes v. MS
Gordon v MS
IV v. Google
Legal Docs
MS Litigations
News Picks
Novell v. MS
Novell-MS Deal
OOXML Appeals
Quote Database
Red Hat v SCO
Salus Book
SCEA v Hotz
SCO Appeals
SCO Bankruptcy
SCO Financials
SCO Overview
SCO v Novell
Sean Daly
Software Patents
Switch to Linux
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



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

No new stories

COMMENTS last 48 hrs
No new comments


hosted by ibiblio

On servers donated to ibiblio by AMD.

Core versus Shipped versus Language versus API | 388 comments | Create New Account
Comments belong to whoever posts them. Please notify us of inappropriate comments.
Core versus Shipped versus Language versus API
Authored by: Anonymous on Monday, May 07 2012 @ 08:49 AM EDT
I'm not sure how you would actually draw any lines between core/basic
Language/API but let me see if I can draw together some thought's I've been
throwing around this thread.....( I wrote before starting this, my conclusion it
seems is very different)

First (IMV):

Everything under java.*
Is a new word for the language

Everything under javax.*
Is a new word that is being tried out, or that might break something if it got
put in java.* so it needs to be kept apart

Everything outside that is not Java. (as indeed et cetera is not actually
English though frequently used)

Second: In Oracles View

All the above is nonsense, all that is "Core" to the language are a
few classes (not yet properly quantified, but broadly Object, Class, String,
Integer, Byte etc...)

Third: Separation of Core and API

I posted this thought just above.....

"Is it the case that the argument proposed by Oracle is that java[.exe]
constitutes the Java Language and rt.jar constitutes the API?"

Well we can look, if you find the rt.jar in your Java installation directory you
can execute the following command

jar -tvf rt.jar

I can highly recommend also adding a |less to that if you really want to try it
out, and a |grep -v "com/sun" before the |less to help a bit more.
(assuming unix CLI)

There's a lot of stuff in there. This is definitely the "API library"

Worthy of note is that you will not find java/lang/String.class

There is a String$1.class which I shall come to in a moment.

Nor will you find in rt.jar any of Class.class, Object.class Integer.class etc
(I have not done a definitive list, I leave that to my betters)

This looks like then we have found Oracles division point, if it is not in
rt.jar then it is in the JVM, if it is in the JVM it is Language, if it is in
rt.jar it is API.

Let's backtrack a bit and clarify what we are talking about, what is

java[.exe] is the JVM for unix[windows]
it is the 'binary' that executes your java program .class file
(note lower case j to distinguish from Java(tm) the platform)

rt.jar is a the class library that goes with the JVM, the API.

The loose analogy is the java=Linux Kernel,
while rt.jar is a zipped up version of the unix /lib and /usr/lib directories

It's not such a bad analogy, this is after all how java was designed to work, if
you place down three boxes and mark them kernel, lib, and usr.lib, and then
stack two boxes on top marked java and rt.jar and then a final one on top marked
application, you would see a fairly good representation of the java WORA stack,
the idea being you can rip out the bottom layer and replace it with something
else, such as Windows

so Oracle (ISTM) assert that java[.exe] is the Java Language and rt.jar is the
Java API

That would seem to bring with it a couple of 'gotchas' though.

There is no this bit, or that bit, it is not divided between two(or more)
things/places as unix is in /usr/lib and /lib /var/lib etc. it is all wrapped up
and packaged as one big massive heap, one file: rt.jar.

So you have one argument that says there's no split, if it's in rt.jar it is

If it's not in rt.jar, it's something else and we don't care, if it is (and all
166 are AFAICS) then it's core, you cannot separate them. (technically you might
be able to, but they do not and AFAIK never have done).

Let's go back to the odd looking String$1.class

What is this? Well to indulge in a bit of technical gobbledegook, this is
something known as an anonymous inner class. What it means is that in the
implementation code for java.lang.String (which is part of java[.exe]) there is
something that creates a whole new class, which is private to the String class
and for use only by the String class.

Now readers might not fully grok what that says, but there is one very important
implication. java.lang.String (a Language Class, part of java[.exe]) cannot,
does not, and will not work without rt.jar being present, thus you cannot
separate java[.exe] the Language from it's APIs, it wouldn't even just be blind
and deaf, it would be most emphatically DoA.

Which is to suggest that even if you 'badge' it as a set of APIs it is required
for Java in the same way that fuel is required to make your car be anything more
than a lump of metal/plastic/rubber. That sounds pretty "Core" to

And just because I'm in the mood to bang another nail in that coffin, here's
what Oracle have to say about it. (I'll make a clicky below for the lazy ones).

This is take from the JDK/JRE files structure description

"rt.jar -- the bootstrap classes (the RunTime classes that comprise the
Java platform's core API). "

And there we see it, rt.jar in Oracles own words, is the "platforms core

Even juicier though is the use of the word "bootstrap", another
concept and this has nothing to do with the things you wear on your feet.

"Bootstrapping is the process by which you load a very small and very
simple pure java program with no dependencies that, in turn, loads, configures,
and runs more complex programs with varying dependencies"

Java is java[.exe] is rt.jar is the Language is the API

Which takes me back to my first point, everything under java[x].* is Language
Oracle said so.

Is it done yet, or would you like me to baste it some more?

[ Reply to This | Parent | # ]

  • clickable - Authored by: Anonymous on Monday, May 07 2012 @ 08:53 AM EDT
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 )