The Spiralcraft Platform

The Spiralcraft Platform is a software environment designed for the efficient creation of novel applications via the expert integration of flexible pre-built components.

The primary goals of the platform are to:

  • Facilitate the rapid development and deployment of robust user experiences.
  • Provide a flexible approach to customization that permits highly detailed tailoring of appearance and behavior where needed, while facilitating the use of pre-existing designs and functionality where acceptable.
  • Support a wide variety of methods to integrate with third-party products and services.
  • Provide powerful tools to integrate and manipulate data from multiple sources to create rich, unique, and contextually relevant user interfaces.
  • Enable the development of flexible, reusable, robust, easily maintained components that can be used in a wide variety of scenarios and that can be combined and customized to create additional reusable components.
  • Scale from low usage on small, inexpensive devices to high usage levels on multi-server environments without requiring costly ongoing development.

Technical Overview

System Environment

The core functionality of the Spiralcraft Platform is written in the Java language to run inside a Java VM. It is routinely tested and deployed on Linux, Apple Mac OS X, and Microsoft Windows.

The platform core contains built-in functionality to manage and store structured data. Standard add-on modules are available to integrate third party SQL databases and other data storage systems.

Web server functionality is provided by a standard add-on module, which means that a third party web server is not required for deployment.

The platform core along with standard add-on modules are sufficient to deploy an application on any machine that contains a JRE (Java Runtime Environment).

Development Approach

The Spiralcraft Platform provides a high level language to create custom applications by defining the structure, behavior, and interconnection of various components.

The language provides a common type system and a common mechanism for referencing primitive values, data models, structural application components, and other information. The language provides transparent access to all objects and functionality available to the Java ecosystem while supporting an extended universe of constructs defined by metadata or by external systems.

The language is designed to support a "declarative" development approach, where the structure and behavior of the application is created by applying properties, relationships, and formulas to application components, and assembling various subcomponents into a multi-layered end product.

The platform and standard add-ons address various domains of application development - the three most common are markup-based UI templating, data model definition, and runtime architecture definition. Each is addressed by a programming facility that adapts the common Spiralcraft language to the demands of the domain.

  • The creation of text or markup based interfaces such as interactive web pages, customized email messages, or formatted documents is handled by a templating language that binds hand-coded markup to complex data models to render individually customized content efficiently for multiple simultanous users, and that can provide for asynchronous interactivity required by single-page web applications.
  • The definition of data models, including types, fields, methods, and schemas, is accomplished using metadata written in a platform-wide standard XML data representation that is also used as the default format for the storage and transport of data.
  • The composition of instantiable object graphs which make up the runtime structure of an application is handled by a XML-based declarative specification format called "builder" that can express composition and inheritance. The "builder" format defines and configures reusable structures that comprise an application and the services that it uses, such as a web server, database, or email queuing service, for instance.

The Spiralcraft platform language comes with a powerful expression syntax which provides a way to manipulate data, define behavior, and connect components together.

The programming facilites and the expression syntax interoperate to permit tight, concise integration between the different development concerns. This integration is made possible by the typing, naming, and scope resolution semantics defined by the platform.

Runtime Model

A Spiralcraft application begins its runtime lifecycle by instantiating a component tree that has been defined and configured using the "builder" syntax. The components instantiated in this step are primarily services that are started to provide resources to other parts of the application, such as a web server, email queue, and system management service.

Services instantiate their own internal component models to achieve their purpose, and these component models in turn instantiate more infrastructure. The particulars of this structure are defined by custom or re-used source code as read by the various programming facilities.

Once the a group of components has been instantiated, it will be "bound". The binding process is where components resolve dependencies from their containers and their environment and perform any final steps in their configuration.

Once a group of components is bound, various properties and references are treated as "constant", as they will never change for the remainder of the runtime lifecycle. Dependent logic found in other components and parts of the expression language syntax rely on this constant information to perform type inference and optimize data flows. The guarantee of constancy is necessary to operate efficiently under high concurrency.

After components are bound, they may be "started" and "stopped" where applicable in order to allocate and deallocate external resources. For instance, a web server component will start accepting connections, and a database component will connect to a database and initialize a shared data cache.

Once running, concurrent messages and data can flow through the runtime structure efficiently. These messages may be associated with HTTP requests from a browser client, or may be generated internally.

(Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners.)