The DreamFactory suite is a mature development and execution platform for crafting rich, event-driven interfaces.

DreamFactory picks up the UI development "gauntlet" with a thoroughly thought out metaphor, framework, and tools whose sophistication matches, and usually exceeds, that of the other application components while remaining straightforward to develop in. The resulting lightweight applications run in Internet Explorer, Mozilla, and Netscape (on the Windows and Apple Macintosh platforms, with Pocket PC, Palm OS, and Linux versions in development).

DreamFactory Flavors
The DreamFactory (DF) suite consists of three components: Runtime, Professional, and Enterprise. The DF Runtime and Professional each provide the development and execution environments. All the tools and features available in DF Runtime are available in DF Professional and vice-versa.

Rather than being locked into the browser environment (and its limitations), DF chose to find a standard, portable way to provide rich UI functionality on a variety of platforms, and settled on implementing DF as a MIME type. Within the browser (and most other MIME-aware applications, such as Word), a DF Runtime can be rendered in full-screen mode or embedded in a Web page (even as multiple instances). DF Professional, on the other hand, is a stand-alone application. DF Enterprise supports the installation and deployment of DF media across networks.

Developing Applications
In DF Professional, projects are opened from a Web server or file system. Runtime can do so as well and, using a key sequence, can open the IDE while an application executes (controlled via security settings), with modifications immediately reflected in the running application.

The DF IDE includes the standard development tools: UI Builder, GUI Objects (Nodes) Palettes, XML/SOAP/WSDL viewers, and wizards, script editors, debugger, etc. While these tools are not uncommon, the completeness of the assembled set is surprising, along with the depth of the functionality available and the ease of use. For example, rather than supporting a single scripting language, DF supports three (JavaScript, VBScript, and DFScript)! Better yet, developers can change the default scripting language on the fly, resulting in the scripting languages being seamlessly converted from one to the other. As another example, variable, method, and object names can be auto-corrected while typing.

The project-structuring metaphor in DF is the XML Tree, with a DF project a hierarchical collection of objects called nodes. The relationships and operations (traversals, tree and node management, introspection), supported on the DF Node Tree are similar to the operations that can be performed on an XML tree.

Dynamic behavior is implemented using scripts. Scripts can be associated with nodes to respond to events and provide utility functions. In addition, every project has a special script called "project" that receives most system messages and parcels them out to the appropriate node. Finally, the DF libraries also contain scripts that can be invoked.

The hierarchical structure of the nodes not only determines the visual organization of the screen and the logical organization of the project, it also establishes the default message passing hierarchy when events are triggered. The messages flow via scripts, from node to node along the tree, up to the project script and then to the libraries, searching for a handler.

A developer can control the delegation of, handle, trap, hook, reroute, and trigger events to and from other controls (even in other projects, depending on the security settings), allowing for fine control over the application behavior and messaging flows. The default behavior of the nodes is generated in the node script when the node added to the project. This gives the developer even more control over the behavior by permitting him or her to modify the scripts controlling the node's implicit behavior. Similarly, errors and system responses to abnormal conditions (errors, warnings, exceptions, etc.) can also be precisely controlled (from the code).

Rendering nodes is platform independent with DF controlling the rendering and not the browser (as DF is a MIME type). This allows for a degree of isolation from the variations and issues related to the underlying platform (browser, O/S, etc.) which DF abstracts and resolves to prevent issues from affecting the users. As a result, applications developed on one platform look identical on the other supported platforms. To achieve this result, the nodes (or any other DF component like scripts, etc.) have no direct interaction with the native environment and DF marshals the requests. Yet, the platform feels very responsive (even under loads), without the delay experienced, between action and response in some purely scripted environments.

Even system resources such as fonts, cursors, etc., are abstracted. For a system-specific resource to become available for development in DF, it is first captured and compressed by DF into a neutral format (for fonts this format is the "DreamFactory Font") that is native to the DF platform, enabling the developer to access the newly created resource.

Every node-type superclass is associated with a plugin that provides its implementation. The plugins, written in C, leverage a cross-platform library provided by DF (making your developed code instantly portable, across OSs and browsers). The runtime and nodes, are lightweight (400K one time runtime environment download, with additional nodes downloaded as needed, then cached).

While most of the node types used to create nodes (e.g., Document Window, XML Palette, etc.) and the features they provide (advanced media types, fonts, drag/drop, etc.) are available in other environments, the large number of node types and the quality of each one is surprising (see Figure 1).

Using XML, WSDL, SOAP, and Web Services
XML, WSDL, SOAP, and Web services can be accessed via the XML nodes (used for accessing XML and SOAP/Web services sources), the API, and variables (XML only). The XML nodes provide a uniform invocation mechanism for different request types. Wizards are available to read in WSDLs (see Figure 2), generate the appropriate proxies and bind the data to nodes. The XML data returned by queries can be persisted, updated, assigned to a variable or unloaded as needed.

Here are some enhancements that DF is planning for their next release:

• Enhancements to the WSDL wizards to map multiple inputs and outputs to/from the GUI directly, plus enhanced support for communication semantics
• New "Document Exchange" wizard that will read in WSDL and generate whole UIs

Objects and associative arrays are also implemented as XML, and XML can be assigned/and extracted directly to/from them. An API is available to manipulate the XML (e.g., to search, select, delete, cut, copy, paste, validate, transform to and from text/binary, etc., on single and groups of elements). XPATH expressions can also be used via the XML Palette Node along with the object/structure/Associative Array notation.

Project Security and Application Deployment
DF Runtime normally operates in a strict security sandbox using a specialized virtual machine (VM) similar to the Java VM (JVM).

DF provides security controls through the VM security policies and the project security (e.g., disabling the key sequence to access to the development environment at runtime).

Company Info
DreamFactory Software, Inc
18640 Overlook Road
Los Gatos, CA 9503
www.dreamfactory.com
Phone: 1-888-399-DREAM (3732)
Fax: 1-408-351-9005
SALES: sales@dreamfactory.com

The DreamFactory Runtime and DreamFactory Professional editions are available at no cost. The DreamFactory Enterprise, providing application maintenance and network deployment facilities, can be evaluated for 30 days, after which a license agreement is required.

Summary
The DreamFactory Suite from DreamFactory software facilitates the creation of enhanced user interfaces for Web-based applications.

The abundance of well fleshed out components and tools married to an intuitive, easily relatable application model, coupled with a solid implementation, makes the platform shine.

The platform has a "mature" feel, with the richness of the environment making the development experience akin to developing a native graphical application where most of the heavy lifting has been done for you and you can focus on the end-user features.

No wonder then, that some of the leading Web services providers (SalesForce.com, Grand Central) are using DreamFactory.

• Figure 1
• Figure 2