Dynamic languages like Ruby and Python have been enjoying a burst of popularity in the Web development community and there are a plethora of frameworks for those platforms that allow them to solve a wide variety of problems. There's one company that's building its own dynamic language from the ground up with a single-minded approach to the problem of fast prototyping for Service Oriented Architectures.

That company is Cretaceous Software, Inc., and the programming language is called Tectonic. Cretaceous characterizes Tectonic as a service-oriented programming language because it "directly reflects the concepts and values that embody SOA." What does this really mean? The answer is probably best illustrated by the example in Figure 1.

The top window in the figure shows the seven lines of Tectonic code required to implement a simple Web Service called "GreetingService" with the operation "Greet." The bottom window of the figure shows the two lines of Tectonic code required to exercise the service. Granted the example is contrived but it serves to illustrate the simplicity of delivering a simple service. No annotations are required, no embedded angle brackets, no code generation, and no special widgets of any kind. The notion of a service and all that it entails is embedded in the language thereby providing a low-impedance mechanism for prototyping services.

Delving In...
You may ask, "How do you run this code?" or "How is it deployed?" The answer is in the Delve Development Habitat, which is essentially an integrated development environment and runtime specifically designed for the Tectonic language. Delve provides an editor, language interpreter, embedded Web server, and complete SOAP stack and is designed around the same SOA fast-prototyping concepts as Tectonic.
To run the example in Figure 1, I typed the code into two separate pages (more on this later) and executed the project. Delve automatically exposed the Web Service on an embedded default server then ran the test client and displayed the results.

The WSDL for the service is available via the Web Service URL with a ?WSDL parameter appended. To test interoperability, I pointed my NetBeans IDE at the Delve hosted service and generated a JAX-WS client that ran and returned data from the service without a hitch.

To begin working with Tectonic you create a project then create a new "page" and put Tectonic code in that page. Tectonic has no concept of a file, and the Delve Habitat doesn't explicitly support mapping of pages or projects to files. You may think of each page as a file but there's nothing in the environment that guarantees this or gives you direct access to a file.

There's no restriction as to what may be put on each page but I'm told it's considered good form to distribute code across pages in a logical manner. For example, a service definition, with its supporting types and schema, should reside on a single page. Each page is assigned a name by the user at creation, and that name should reflect the purpose of the page. Pages are ordered in a project in the order they should be executed.

When I installed the Delve Habitat, it automatically configured a server on the standard loopback address, 127.0.0.1. This server is referred to as the "default server." Additional servers can be configured to run in the Delve Habitat on any IP addresses and ports required. Each server is named and can be configured to start automatically when Delve is launched. Servers are visually displayed in a Server Panel in the Habitat and each service deployed is displayed under the server. By default the URL suffix for each service is the project name followed by the service name, but Delve lets you customize it to whatever you want.

Schema
The Tectonic language allows for the definition of XML Schemas. This is natively supported and acts as nice shorthand for constructing schemas without additional tools. In fact, all type definitions in the Tectonic language are associated either explicitly or implicitly with a schema.

A nice feature of the Delve habitat is that it directly supports XML namespaces. The habitat lets users define a common set of namespace mappings that are shared across all code executing in the habitat. This reduces the boilerplate namespace declarations when working across a number of projects.

XPath
So now that you've imported or constructed a schema in Tectonic, how do you navigate the document hierarchy? You might expect a typical dot (.) notation for member access as in other languages, but Tectonic uses XPath notation natively for its member access mechanism. The forward slash "/" character is used as an "accessor" operator. As you would expect with XPath, when the forward slash is placed to the right of an element instance, it produces all child elements with names matching the operand appearing to the right of the accessor.

Resources
Since Delve doesn't have a notion of file, it refers to external entities such as XML documents and schema files as "resources." The resource construct lets a Tectonic developer ignore the physical aspects of the resource. The developer only has to treat the resource abstractly as a document and not be concerned with whether or not the resource is in the local file system or somewhere out there on the Internet. Essentially, this lets Tectonic view a document as a discrete entity rather than the result of fetching data from the system and massaging it into a particular form.

Resources are configured through the Delve Habitat using a resource wizard that lets the developer select the document to associate with a resource. Delve supports mapping a WSDL document to a "Foreign Service Interface" resource. This allows for simple access to external Web Services as shown in the lower window in Figure 1. The ease with which external Web Service calls can be mocked up in the Delve environment lends itself well to testing. I could envision training testers in using Tectonic and Delve and have them build a suite of test cases for all services developed in a project or across an enterprise. Tectonic can also be used to mock up a service to facilitate client development before the "real" service is delivered.

Licensing & Support
Cretaceous Software has kept the licensing simple and inexpensive. Delve Development Habitat 1.0 is $75 per developer seat. Cretaceous offers unlimited online support and up to four phone support incidents for license holders for up to 12 months after purchase.

Conclusion
In a world where sexy BPEL orchestration tools are prevalent, a simpler language-oriented model can be a welcome alternative. I must admit that when I was asked to review Cretaceous' product, I was skeptical. But as I tested the tool and dropped into other environments to test interoperability, Tectonic and Delve always seemed simpler and quicker to use.

The Tectonic language and Delve Development Habitat remove the impedance mismatch between code and service access typical in many languages. The language and tools are simple and straightforward to use, but can support complex implementations
Any readers out there who are looking for tools that do fast prototyping in an SOA environment should definitely consider Tectonic and the Delve Programming Habitat.