NetKernel Development Approach
NetKernel supports a highly effective and productive development
approach that includes three distinct phases:
Construct, Compose,
and Constrain.
Construct is the phase during which
fundamental resources and services are written.
These resources can be developed in Java or a scripting language
and is described in detail in the
Extension Guide
.
Many core capabilities have already been written and are covered
in the
API Reference and Services Guide
Compose is the phase during which the fundamental
services are orchestrated in a way to build the NetKernel
solution.
This requires the application of various patterns, the sequencing
of service calls with a scripting language, and the
establishment of relationships between modules.
Constrain is the final phase when constraints
are applied to a working system to manage complexity, add security, transactions,
restrict the range of values accepted by the system (e.g. "data validation"),
and other tasks.
While the
Construct, Compose,
and Constrain
approach may seem different at first, you will find that
all essential development steps are covered.
The difference is that development steps are reordered in
a new way that fits the strengths of NetKernel
and which supports rapid understanding of the
required solution.
Indeed, the three steps do not specify the order of development.
Many NetKernel applications are built by focusing first on the Compose
phase while the Construct phase is either deferred or developed
in parallel.
From a project risk perspective, the Compose phase is most closely
associated with the essential business functions of the application.
By focusing first on the Compose phase, overall project risk can be
reduced because application user feedback can be obtained earlier
in the project than with other approaches.
Traditional approaches, such as Object Oriented development
are still present.
For example, you will use OO when
Constructing fundamental
resources and services in Java.
When Composing, you will use a combination
of functional programming (with active URIs) and scripting.
Development using Patterns is important
and very effective during the composition phase.
Finally, techniques such as programming by contract (PBC) can be
applied during the Constrain phase
of development.
Examples
Examples of this development approach are discussed in depth in the
Architects Guide
.