Seedling is a generic application platform that enables streamlined development of Java applications from reusable components. It is appropriate for applications of any kind, headless or GUI, server or client.
The core Seedling platform provides a flexible mechanism for constructing, configuring and connecting the primary objects of an application. This mechanism requires no Java code, so any component property can be reconfigured without recompilation. Instead of having your code encumbered by verbose and confusing initialization methods, Seedling dynamically configures the running program through specifications written in clear text files. This reduces the lengthy trial and error of compile/test cycles and leads to more maintainable and concise code.
Seedling components are arranged in a hierarchical namespace, providing the platform's basic "branch/node" metaphor. Each component has a unique address within the tree by which it can be accessed from other nodes. A configuration tree specifies the structure of the tree, and the address, type and properties of each node. This is a simple model for organizing and visualizing an application. However, Seedling extends this model in two ways.
The first extension is the concept of configuration layers. Instead of allowing only a single tree to configure components, additional trees can be added in "layers". "Higher" layers can alter the specifications provided by "lower" layers (for example, change the value of an individual component property, or change the type of a component altogether). Each layer can also add entirely new nodes to the application (for example, a new system-wide service, or a new menu item in a GUI).
The second extension to the basic hierarchical model is scopes: multiple independent hierarchies, each with its own instances of various nodes. Scopes are themselves arranged hierarchically; there is a single "global scope", from which are derived any number of "local scopes" (which may themselves have subscopes). A scope's address space inherits the nodes housed in its parent scope, so each scope provides access to a unique set of scoped objects in addition to the global objects available to all scopes. This advanced feature can easily implement many common architectural forms, such as user profiles (where each scope houses component instances unique to one user), HTTP sessions (where each scope houses data specific to a browser session or request), and GUI frames (where each scope holds the widgets and logic of a single window).
Given this explanation, the core platform can be understood as a powerful model of component instantiation, defined by three key concepts:
A Seedling application (that is, an application built using the Seedling platform) is made up of one or more modules. Each module contributes new components to the tree, and customizes the configuration of existing components.
Each module has two aspects: a configuration layer that specifies the module's runtime components, and (optionally) a JAR file that provides any necessary classes that aren't provided by another module. A module can be deployed into an existing Seedling runtime system simply by copying it into a "modules" directory.
The project includes support for compiling, testing and packaging Seedling modules.
Components used by Seedling can be completely decoupled from each other in their implementation. This leads to simple, highly reusable classes, which in turn enables rapid development and great flexibility. From this perspective, Seedling components are similar to (and generally compatible with) JavaBeans, but the platform provides architectural support for composing beans into a complete application.
Seedling is made from 100% Pure Java, and requires Java 5.0 or later. It is built using Apache Ant and tested using JUnit. To date, it has been tested and deployed on Mac OS X, Windows 2000, and Windows XP.
Seedling originated out of need. While launching development of a new commercial product, the primary developer attempted to find an Open Source framework as powerful as the ATG Dynamo Nucleus with which he was familiar. When no such framework could be found, he decided to build one. The initial code for Seedling was written in the fall of 2001, and the platform has been under constant evolution since then. In the summer of 2002, the developer's employer released the first commercial product using Seedling: a client-server application with a Swing front-end. Now the Seedling project is available under the OSI-approved Apache License 2.0.
The codebase should be considered beta-quality as it is going through significant refactoring and extension. However, the overall architecture of Seedling has been stable for some time. We don't anticipate the need for applications using the platform to require many changes as these refactorings take place. We're also working to form a Road Map that will lay out a development plan towards a final 1.0 release.
Comprehensive documentation of Seedling is under construction; we call it The Seedling Book. It's intended to go hand-in-hand with the API Reference pages.
We encourage feedback. We don't just encourage it, we love it, we crave it. Join the Seedling-user mailing list and send your questions, suggestions, criticism, and Good Vibes. You should also visit our SourceForge project summary for more information.
|