This chapter presents a small overview of the differences between Inferno/Limbo and JavaOS/Java. Most of the comparisons originate from Lucent sources [13], so they are of course a bit biased. To balance things, some personal opinions have been added at the end.
A basic error often made is to directly compare the Inferno environment with Java. The two technologies are not complementary, as Java is a programming language, whereas Inferno is a complete network operating system with a kernel, a programming language (Limbo) and associated libraries for communications, security, and authentication, and communications protocols.
What can be compared, however, is Java and Limbo, and to some extent, JavaOS and Inferno.
The two languages are similar in many ways. Both use a C-like syntax, compile to a virtual machine that can interprete or compile on-the-fly for portable execution, use garbage collection, and support the Unicode character set. Java is derived from C++ and uses the object model to provdie interfaces to system services, whereas Limbo is a bit simpler in that respect. On the other hand, Limbo has more basic higher-level types and programming concepts, like communications channels, built into the language.
The garbage collector of Limbo is more suitable for real-time constraints, because it has a constant overhead (no surprises), and works in an immediate mode. This means that memory is reclaimed directly after the last reference is released, which minimizes the memory requirements during execution. Windows, network connections, and file descriptor are also tied directly to the garbage collector, and thus Limbo manages the lifetime of those system resources completely. For example, if the last reference to a window is removed, the window instantaneously disappears. In Java the garbage collector runs as a separate, low-priority thread.
The Limbo graphics toolkit uses the higher-level Tk toolkit [14], which is in many ways far more advanced than the current AWT of Java. The floating point package of Limbo provides control of exceptions, and there are other differences as well, even though the basic libraries cover the same ground in both languages.
Another difference, that is not directly related to the syntactical features of the languages, is the implementation of the virtual machine. The Inferno virtual machine, Dis, uses a memory-to-memory architecture, while the Java virtual machine, JVM, uses a stack machine. The memory-to-memory architecture translates easily to native instruction sets on modern processor architectures, which makes the on-the-fly compilers very small, and the resulting code very fast. For the same reason, the Dis interpreter is also much smaller than the Java virtual machine.
JavaOS [15] is intended mainly for network computers, which means that it is more restrictive than the Inferno environment. JavaOS implements the Java Base Platform, and iincludes the Java Virtual Machine, the Java Embedded API, and underlying functionality for windowing, networking, and the file system. One advantage of JavaOS compared to Inferno is that Sun is developing microprocessors (picoJava, microJava, and UltraJava) that directly supports the JVM. On these specialized microprocessors Java might catch up with the speed of on-the-fly compiled Limbo. This advantage does not apply for normal microprocessors, though, and it might take a while before these specialized microprocessors are mass-products.
The Java-based concept seems to be a bit confusing at the moment, because of the varying terminology (Java, Java Platform, Java Base Platform, JavaChip, JavaOS.) Inferno is a much cleaner concept, and more generic. The hype-factor surrounding Java works in the favour of Java, at least for know, but unless some serious office automation software appears soon, Java might lose its current edge in the market.
When comparing the two languages, both are quite primitive compared to higher-level languages like Python [16] or Common Lisp, and contain a lot of technically boring limitations. Limbo continues the C tradition of using a lot of special characters and combination of them to achieve syntactical shortness, while Java is sprinkled with magical keywords.