JAVA and Inferno

from :  http://inferno.lucent.com./inferno/infernojava.html

                Let us not confuse ourselves with JAVA, HotJava, LIMBO, and Inferno. They are all not directly comparable as they are distinctly different in terms of their characteristics and purposes in the world of computing. JAVA is a platform - independent language, and HotJava is the first browser that is written in JAVA and capable of supporting JAVA applets. LIMBO is another programming language, which is also machine - independent, used in development of a new operating system called Inferno. Here we'll explore Inferno and LIMBO in details relative to JAVA.

                As stated before, JAVA is an architecturally independent programming language, while Inferno is a full operating system including a kernel, programming language, communications protocols, libraries, security and authentication, naming protocols, APIs, and so on. Inferno is therefore a more comprehensive offering, one that addresses more problems of building networked applications. Although Inferno includes a programming language, namely LIMBO, it will support others, and JAVA is an obvious candidate. Let's discuss the properties of LIMBO and Inferno further.

                LIMBO, being supported by the full Inferno environment, is therefore capable of handling network problems. When a LIMBO program begins execution, it has a fixed interface to these services, hence is more portable than any language-only solution. For example, the network API, which is identical in all Inferno systems, is independent of the hosting operating systems o the network itself. Another example is security; features such as digesting and encryption are done in the lowest levels of the systems, allowing an application to use them uniformly, or even remain unaware of their presence, such as when a remote application wishes to establish a secure connection to a local one. Also remember that Inferno was designed to manage the networks, servers, and other network elements, not just the client applications, thus giving Inferno the means to configure the execution of programs from pieces anywhere in the network, not just on the client.
The difference of depth is the real distinction between Inferno and JAVA.

Similarities.

We can summarise the similarities of JAVA and Inferno as follows;
  1. Both use C-like syntax
  2. Both compile to a vertual machine code for portable execution
  3. Both have the capability of automatic garbage collection to manage memory
  4. Both support Unicode character set
Note that JAVA is derived from C++ and uses the object model to provide interfaces to system services. On the other hand, LIMBO avoids the complex object -oriented features of C++ but has more basic types - lists, strings, tuples, etc. - and programming concepts - threads, communication channels - built into the language.

Differences

                LIMBO differs from JAVA in several important ways. For LIMBO, concurrency and communication are an intrinsic part of the language and the virtual machine, and are used extensively in the programming model. LIMBO also has more general pointers, without sacrificing safety. LIMBO's garbage collector, having constant overhead so that its operation does not conflict with real-time constraints, reclaims memory as soon as the last reference is released, to minimise the memory needed for execution. LIMBO completely manages the lifetime of system resources b tying windows, network connections, and file descriptors to the  garbage collector.

                Also, LIMBO programs are built as sets of modules that export interfaces whose implementation may be interfaces whose implementation may be needed at any moment; it may load and even unload modules as its environment or execution dictates. The ease of exporting interfaces across the network allows modules to be run remotely.

                LIMBO has numerous libraries, packaged as modules. While the current set covers some of the same ground as Java's libraries, there are differences.

                LIMBO's virtual machine, Dis, is well suited to JIT compilation. The machine is a memory-to-memory architecture, not a stack machine, that translates easily to native instruction sets. In fact, many Dis instructions translate to a single Pentium instruction. The on-the-fly compilers are small - the implementation for Intel 386 architectures is only about 1300 lines of C - and result in code that performs within about a factor of two of compiled C. For the same reason, the Dis interpreter is considerably smaller than the implementation of the Java virtual machine.

                Plug-ins are unnecessary in LIMBO, as combinations of programs are composed as modules; codecs for playing things like AVI and QuickTime clips are written as Limbo modules. Although this means that the existing C-language implementations have been rewritten, it also means that the modules are completely portable.

Perhaps most important, LIMBO and Dis, like all of Inferno, were designed from the ground up specifically for the job of providing an environment for networked applications. Therefore Inferno has properties that address the problems of building and deploying networked applications.

Since many of the issues of programming in a networked environment are addressed by other parts of the system, it makes sense for JAVA programs to run in the Inferno environment, where they can gain many of the advantages of uniform access to system services. Hence Inferno is more a complement to JAVA than a competitor with it.

Micorsoft's ActiveX
Back to Main Page