- Sun's JDK
- Sun's Linux JDK
We're going to focus on OpenJDK, since Oracle is probably giving Sun's Java a very slow death. We know at least two things:
- OpenJDK is written in Java.
- BSD's ports system uses source code to build the packages locally
Points 1 and 2 together mean that I need Java to build Java. This is the same problem that Haskell has when you attempt to build it. There's a few ways of solving it:
- Have a cheap and cheerful Java compiler written in a language that you already have a compiler for.
- Use an existing Java compiler to build Java.
OpenJDK does not supply a compiler written in anything other than Java. This means that to install Java, you're relying on a non-free Java.
Luckily, there are multiple solutions:
- A bare-bones (aka bootstrap) Java compiler written in C/C++ to bootstrap OpenJDK into life
- Binaries from OpenJDK
However, both of these have some major problems.
Writing a bootstrap compiler in C/C++
Java is a big language. I presume something like 95% - 99% of the language features in Java are in use in the OpenJDK compiler and virtual machine.
This means that any bootstrap compiler & associated VM will be very big. Possibly warranting it's own project.
Being produced by the OpenJDK community and written in something-other-than Java will also likely be an issue -- I assume the OpenJDK community is most proficient and prefers writing things in Java.
Binaries from OpenJDK
This is a problem, since the binaries that OpenJDK sends out will have to be for every OS and every architecture that they want to support. This is a huge burden and simply not feasible
Can you imagine having to either cross-compile then test on, or directly compile OpenJDK on ARM, AMD64, x86, MIPS, SPARC? Not to mention the array of OSes that may run on the above architectures.
FreeBSD's solution attempts to neatly side-step the solution. Their port of OpenJDK relies on the "DiabloJDK". This is
Sun's Oracle's JDK licensed by the FreeBSD foundation for usage. I'm not sure what the exact terms are, but this makes me uneasy (personally).
To install OpenJDK, you grab the DiabloJDK package off Oracle's un-navigable site and stick it in a very particular directory. When OpenJDK is being built, it uses DiabloJDK to build itself. You are then free to remove the DiabloJDK.
This is, officially, a bitch. Oracle require you to signup and agree to their Ts & Cs before allowing you to download stuff from their site. However, it does mean that OpenJDK don't actually have to bother very much about FreeBSD-specificities.
That's right folks, to get an open implementation of Java on your FreeBSD box, the standard method is to get a non-free implementation of Java on your FreeBSD box.
My (Proposed) Solution(s)
We write a small, Java interpreter in PyPy (RPython), and directly run the un-compiled OpenJDK code on itself to compile it.
Interpreters are supposed to be quick and easy to write in PyPy and it should therefore be within someone's grasp to do so.
Obviously, you'd need to install PyPy before this, and I think that requires Python, which is a very odd dependency for OpenJDK to have.
LLVM is also supposed to be nice for interpreters and the like. Why not have OpenJDK depend on the LLVM tool chain? Maybe we can have a Java-to-LLVM bitcode compiler?
This is (as in the PyPy idea) a little bit of a strange idea, but most languages eventually need a C compiler to bootstrap them, why not use something closely related?