NetKernel Development Fundamentals

NetKernel is a highly dynamic and flexible environment that works at the logical level, above and separated from the physical level of computing.

Most developers are used to working at the physical level with Java, Ruby, PHP, or a similar language. When developing at the physical level an Integrated Development Environment (IDE) makes work easier as it adds dynamic capabilities (such as introspection) to a fundamentally static language.

The majority of NetKernel application development occurs at the logical level. Some development at the physical level may be needed to build new resource models or services. Because applications and development needs vary widely, it is not possible to recommend a specific set of tools or a particular configuration. This section instead presents the information you need to assess tools and to devise a suitable configuration.

Logical Level Development

When working at the logical level most of the time is spent composing systems from constituent parts. Some developers find that a simple programmer's text editor is all they need for NetKernel development. A lot of files contain XML so an editor that understands XML syntax is a benefit. If you elect to compose resource or sequence requests with a scripting language such as Ruby or BeanShell, it would be beneficial to use an editor that understands the syntax of your language.

At the highest level of development, one configures one or more transports and modules to route requests to the proper endpoints. To do this work and to verify that all is working correctly, it is helpful to have a tool that can make transport requests and display the results. Even if the final transport is not HTTP, it is very convenient to use HTTP during development as a web browser can function as the injection tool as well as display the response. In addition there are many tools that work with HTTP to conduct performance testing, validation, etc.

NetKernel provides several tools that help with logical development. To verify that resources and services within modules are configured correctly, use the Resource Request Trace Tool to define a resource request and inject it into either the private address space directly or send it to the module as an external request. Similarly, for Java classes, the Class Trace Tool allows you to specify a class name and determine where in the NetKernel class search path it exists.

The Debugger is a logical level debugger that allows you to set breakpoints based on a number of parameters which if matched will stop a request and allow you to investigate it fully. The new Request Visualizer allows you to capture root requests and explore its full execution, including sub-requests to an unlimited depth.

Finally, for testing the XUnit testing framework and tool allow you to define tests against modules, services and resources which can be run repeatedly for regressions testing.

Dynamic Environment Development

NetKernel support an Edit-Run development cycle compared with an Edit-Compile-Run cycle required by most languages.

To support Edit-Run, NetKernel manages the loading of resources (code, images, files, etc.) on a module-by-module basis. Some aspects are external to modules, such as NetKernel instance information and the system-wide cache.

The following table describes various system-wide changes and how to effect them.

Change	Detected By
Add a new module	Initiate a hot restart
Flush system cache	Initiate a hot restart
Change an entrypoint	Initiate an Quick Entrypoint Reindexing from the Control Panel
Reset system statistics	Initiate a hot restart
Change transport configuration	Initiate a cold restart

The following table described various module changes and how to effect them.

Change	Detected By
Change a module definition file	Automatically detected if the module is marked as <dynamic/>, otherwise initiate a cold restart
Modify a Java class file	Automatic, if dynamic Java compilation is enabled, otherwise initiate a cold restart

At development time new classes should be compiled using the classpath set in the IDE (as described above). However at runtime, the bootloader ensures that an independent classpath is used for execution. In fact, NetKernel dynamically builds classloaders for each module to ensure each module is truly independent. Modules in NetKernel are aware of and can locate only their classes and resources.

Physical Level Develoment

For physical level development read through the remaining entries in this section to see which IDE configuration best matches your needs.