Inferno

inferno - n. (plural - infernos), scene of horror or distress, esp. in fire; hell
* Little Oxford Dictionary; Sixth Edition

from : http://inferno.lucent.com./inferno/index.html
: http://inferno.lucent.com./inferno/infernosum.html

Developed by the Computing Sciences Research Center of Bell Laboratories (the research arm of Lucent Technologies), Inferno^tm is a new network operating system and programming environment to deliver content in a rich environment of heterogeneous networks, clients and servers. Basically, the Inferno system includes the Inferno kernel, the Limbo^tmprogramming language, reference APIs that include interfaces for networking and graphics, network protocols, security and authentication, and various toolkits.

There are a variety of network environments that Inferno can be an important part of; for example those supporting advanced hand-held devices, TV set-up boxes attached to cable systems, and inexpensive networked computers. Not to mention the most visible new environments such as cable television, direct satellite broadcast, the Internet, and other networks. Why is it so important and useful to have an operating system such as Inferno implemented in such networks? As the entertainment, telecommunications, and computing industries converge and interconnect, a variety of public data networks are emerging, each potentially as useful and profitable as the telephone system. But unlike the telephone system, which started with standard terminals and signaling, these networks are developing in a world of diverse terminals, network hardware, and protocols. Only a well-designed, economical operating system can insulate the various providers of content and services from the equally varied transport and presentation platforms. This is why we need such an operating system. Inferno is a network operating system for this new world.

Portability

Again portability (as in JAVA) gives Inferno its special strength above others. Let us investigate the scope of Inferno's portability and versatility :

Portability across processors	Inferno currently runs on Intel, Sparc, MIPS, ARM, HP-PA and AMD 29K architectures, and is readily portable to others
Portability across environments	Inferno runs as a stand-alone operating system on small terminals, and also as a user application under Windows NT, Windows 95, Unix (Irix, Solaris, Linux, AIX, HP/UX) and Plan 9. In all of these environments, Inferno applications see an identical interface
Distributed Design	The identical environment is established at both the user's terminal and at the server, and each may import the resources of the other; aided bye the communications facilities of the run-time system, applications may be split easily (and even dynamically) between client and server.
Minimal hardware requirements	Astonishingly, it runs useful applications stand-alone on machines with as little as 1 MB (!!) of memory, and does not require memory mapping hardware.
Portable applications	Inferno applications are written in the type-safe language LIMBO (!!), whose binary representation is identical over all platforms ( compare this with JAVA !)
Dynamic adaptability	Applications may, depending on the hardware or other resources available, load different program modules to perform a specific function.

Inferno is parsimonious enough in its resource requirements to support interesting applications on today's hardware, while being versatile enough to grow into the future. In particular, it enables developers to create applications that will work across a range of facilities. An example: an interactive shopping catalog that works in text mode over a POTS modem, shows still pictures (perhaps with audio) of the merchandise over ISDN, and includes video clips over digital cable. Clearly not everyone who deploys an Inferno-based solution will want to span the whole range of possibilities, but the system architecture should be constrained only by the desired markets and the available interconnection and server technologies, not by the software.

Inferno Interfaces

The role of the Inferno system is to create several standard interfaces for its applications:

Applications use various resources internal to the system, such as a consistent virtual machine that runs the application programs, together with library modules that perform services as simple as string manipulation through more sophisticated graphics services for dealing with text, pictures, higher-level toolkits, and video.
Applications exist in an external environment containing resources such as data files that can be read and manipulated, together with objects that are named and manipulated like files but are more active. Devices (for example a hand-held remote control, an MPEG decoder or a network interface) present themselves to the application as files.
Standard protocols exist for communication within and between separate machines running Inferno, so that applications can cooperate.

At the same time, Inferno uses interfaces supplied by an existing environment, either bare hardware or standard operating systems and protocols.

Most typically, an Inferno-based service would consist of many relatively cheap terminals running Inferno as a native system, and a smaller number of large machines running Inferno as a hosted system. On these server machines Inferno might interface to databases, transaction systems, existing OA&M facilities, and other resources provided under the native operating system. The Inferno applications themselves would run either on the client or server machines, or both.

External Environment of Inferno Applications

The purpose of most Inferno applications is to present information or media to the user; thus applications must locate the information sources in the network and construct a local representation of them. The information flow is not one-way: the user's terminal (whether a network computer, TV set-top, PC, or videophone) is also an information source and its devices represent resources to applications. Inferno draws heavily on the design of the Plan 9 operating system in the way it presents resources to these applications.

The design has three principles.

All resources are named and accessed like files in a forest of hierarchical file systems.
The disjoint resource hierarchies provided by different services are joined together into a single private hierarchical name space.
A communication protocol, called Styx, is applied uniformly to access these resources, whether local or remote.

In practice, most applications see a fixed set of files organized as a directory tree. Some of the files contain ordinary data, but others represent more active resources. Devices are represented as files, and device drivers (such as a modem, an MPEG decoder, a network interface, or the TV screen) attached to a particular hardware box present themselves as small directories. These directories typically containing two files, data and ctl, which respectively perform actual device I/O and control and status operations.

Internal environment of Inferno applications

Inferno applications are written in LIMBO, which was designed specifically for the Inferno environment. Its syntax is influenced by C and Pascal, and it supports the standard data types common to them, together with several higher-level data types such as lists, tuples, strings, dynamic arrays, and simple abstract data types. A communication mechanism called a channel is used to connect different LIMBO tasks on the same machine or across the network. A channel transports typed data in a machine - independent fashion, so that complex data structures (including channels themselves) may be passed between LIMBO tasks or attached to files in the name space for language-level communication between machines. Note that multi - tasking is supported directly by LIMBO; so by building channels and tasks into the language and its virtual machine, Inferno encourages a communication style that is easy to use and safe.

Modules are self-contained units with a well-defined interface containing functions (methods), abstract data types, and constants defined by the module and visible outside it. Modules are accessed dynamically, that is, when one module wishes to make use of another, it dynamically executes a load statement naming the desired module, and uses a returned handle to access the new module. When the module is no longer in use, its storage and code will be released. Remember that LIMBO programs are built of modules, therefore the flexibility of its modular structure contributes to the smallness of typical Inferno applications, and also to their adaptability.

LIMBO is fully type-checked at compile- and run-time; allowing LIMBO programs to run safely on a machine without memory - protection hardware. Moreover, all LIMBO data and program objects are subject to a garbage collector, built deeply into the LIMBO run-time system. All system data objects are tracked by the virtual machine and freed as soon as they become unused. LIMBO programs are compiled into byte-codes representing instructions for a virtual machine called Dis^tm. When loaded into memory for execution, the byte-codes are expanded into a format more efficient for execution. There is also an optional on-the-fly compiler that turns a Dis instruction stream into native machine instructions for the appropriate real hardware. This can be done efficiently because Dis instructions match well with the instruction-set architecture of today's machines. The resulting code executes at a speed approaching that of compiled C.

The Environment of the Inferno System

Inferno creates a standard environment for applications. Identical application programs can run under any instance of this environment, even in distributed fashion, and see the same resources. Depending on the environment in which Inferno itself is implemented, there are several versions of the Inferno kernel, Dis/Limbo interpreter, and device driver set.

When running as the native operating system, the kernel includes all the low-level glue (interrupt handlers, graphics and other device drivers) needed to implement the abstractions presented to applications.
For a hosted system, for example under Unix, Windows NT or Windows 95, Inferno runs as a set of ordinary processes. Instead of mapping its device-control functionality to real hardware, it adapts to the resources provided by the operating system under which it runs. For example, under Unix, the graphics library might be implemented using the X window system and the networking using the socket interface; under Windows, it uses the native Windows graphics and Winsock calls.

Inferno is, to the extent possible, written in standard C and most of its components are independent of the many operating systems that can host it.

Security

Inferno provides security of communication, resource control, and system integrity. Each external communication channel may be transmitted in the clear, accompanied by message digests to prevent corruption, or encrypted to prevent corruption and interception. Once communication is set up, the encryption is transparent to the application. Inferno is secure against erroneous or malicious applications, and encourages safe collaboration between mutually suspicious service providers and clients.

JAVA and Inferno - a comparison
Take a peek at Inferno Desktop
Return to Main Page

ABSTRACT

"If, reader, you are slow now to believe What I shall tell, that is no cause for wonder, For I who saw it hardly can accept it."