1060® NetKernel™ is advanced software infrastructure. Architecturally it is grounded on and extends ideas found in Unix and the REST style of design. The result is a powerful and flexible logical computing environment called resource oriented computing.

NetKernel is implemented as a precision-crafted microkernel that sits between the traditional physical computing layers and the new logical resource oriented computing layer.

Within the logical layer information resources are processed by services without worries about physical data types. Resources can be composed from other resources and services "snap-fit" together. Common services can be shared among applications and all can be logically reconfigured at runtime - supporting hot-deployment and system configuration rollback.

Resource Models

Resource models are the foundation of resource oriented computing.

A resource model comprises one or more resource types and services that process, produce, or transform the type. For example with the Image resource model you can rotate, crop or scale an image resource with simple services without knowing that the physical representation and code are based on the Java 2D APIs. With the XML resource model you can use XQuery, XSLT, etc without knowing which physical in-memory model is used.

Transports

Transports detect events and generate a corresponding root request that is injected into the system and returns the response. For example, the HTTP transport detects the arrival of a request from a browser and the JMS transport detects the arrival of a message.

Language Runtimes

In NetKernel a programming language runtime is simply a service. While grounded in the physical layer, resource requests can be injected into the logical layer with the NetKernel Foundation API. NetKernel supports a wide range of languages including Java, Ruby, Python, Groovy, JavaScript and BeanShell.

Microkernel

The microkernel intermediates between the logical and physical layers providing complete isolation - all logical requests are processed by the microkernel. This isolation and use of logical indirect addresses allows the microkernel to optimize or restructure a live system.

The microkernel is a precision-crafted operating-system caliber process that resolves logical addresses to physical layer software endpoints. A Unix-like process table holds pending requests for scheduling onto threads held in a tightly managed thread pool. The microkernel is asynchronous, enabling both synchronous and asynchronous processing and its sophisticated algorithms optimizes CPU throughput while minimizing thread contention and context switching costs. Developing applications at a logical level means it is impossible to write non-threadsafe systems.

Consequences

The architectural consequences of providing a logically coupled environment are significant.

• Caching - the result of a resource request is an immutable snapshot representation of the resource's state. Caching this under the resource's address (as the cache key) along a dependency hierarchy that instantly invalidates entries when their dependencies change means that redundant computations are eliminated.
• Linear Scaling - all resource requests are intermediated by the microkernel. Work is scheduled for execution on a thread from the tightly managed thread pool. The result is thread-less programming at the logical layer and full CPU core utilization at the physical layer.
• Decoupling - logical addressing induces loose coupling and flexible relations between a resource provider and clients. A change in either side need not impact the other. Parts of the system can even evolve from generation to generation independently, even in a fully live system.
• No Side-Effects - Just as Web sites can be extended indefinitely and progressively without ground-up redevelopment, NetKernel software systems can be extended and modified without fear of side-effects.

Moving computations upward to the logical layer allows wide-ranging optimizations in the physical layer. For example the physical representations of a resource can be 'compiled' into an optimal form prior to use. More generally, code can be compiled, streams parsed, data turned into object models - and all of this can be cached in the most computationally valuable form to eliminate redundant computations.

The fine-grained dependency cache allows the system to 'self-balance' as currently valuable resources are retained and others discarded. Because the cache knows the economic value of each item it automatically self-optimizes the system without additional code or metadata annotations - even as the system use pattern changes.

Additionally, logical address spaces permit elegant design patterns. For example, create functional layering, f(g(x)), where one service transparently wraps and intercepts another service with a simple wrapping of one address space around another - all without bytecode manipulation.

For more depth please take a tour of the detailed technical features and advanced management infrastructure provided with NetKernel Standard Edition.