The global frame of the problem that syntelos and gap-data pursue is web editing, collaboration and automation. This frame is contained by
interaction, a subject perhaps best illuminated by
Peter Wegner and
Dina Goldin.
Within the gap-data frame is first
appengine. A
servlet container with
a collection of APIs for scalable applications' development.
The first most important API in appengine would be the Datastore, a
protobuf client for
BigTable. BigTable is...
a partitioned (sharded) sorted list (array) of strongly typed, structured data objects.
Gap Data generates and compiles java sourcecode for persistent application data structures over the Datastore API on BigTable.
These data structures are defined in an
IDL-like schematic that abstracts from the code to be generated. The ODL schematic has a text representation as in the following example.
package gap.data;
path /templates;
child Template version 2
parent Resource
implements LastModified
implements HasName
{
Key key;
*unique String id;
*hash-unique String name;
Long lastModified;
Text templateSourceHapax;
List.Short<TemplateNode> templateTargetHapax;
}
This example illustrates the web tools centricity of Gap Data's ODL, most specifically in the required qualified fields
*unique and
*hash-unique for the
"/templates/310ab222bd" style of Web API that ultimately results. The unique field is the public web ID, and one or more hash-unique fields are required to produce (project) an ID for the class.
This example also illustrates the parent- child relationship. The class declaration headline shows that the Template class is declared as a child of the Resource class. We can see the use of another parent- child relationship in the case of the TemplateNode class as a child of the Template class. This relationship is declared as "short" in the field named "templateTargetHapax".
There are two kinds of parent- child relationships among these network data structures: long and short. The long relation is suitable for large numbers of the child class in the relation, and the short is suitable for small numbers of instances of the child class in the relation. The short is an
entity group, while the long is not. The entity group requires all of its elements to be contained within one BigTable shard or partition. Typically one has designed with a theoretical upper bound of ten or a perhaps a hundred objects in an entity group.
In the particular case of the Template and its parsed GapData/Hapax3 TemplateNodes, we're pushing the entity group into relatively large numbers (e.g. a thousand instance objects in the list) for another reason. The coherency of this list is very particular as the parse tree of the field of type
Text named
templateSourceHapax.
And we're doing that -- persistenting a parse tree -- in service of our design program for federated collaboration and automated modification. In doing so, we've found a structure for the problem- solution set for collaboration and modification in terms of interaction: an otherwise messy problem is conceived in a crisp and clean interactive coulple
The Template class description has a few more features. The class declaration "headline" includes an "implements" keyword for java binding programming language interfaces into the generated class. The interfaces in the example describe the fields
lastModified and
name. And finally, the "path" feature identifies the Web API path element for the class, it's leading slash is merely notational.
From these schematic object descriptions, Gap Data generates java source code for a class that implements persistent and network data binding. Common application programming functions are generated as static methods for creating, retrieving, updating and deleting instances and lists of the class with respect to storage. And instance methods are generated for binding data to supported network I/O formats.
These classes are generated via Hapax3/CTemplate, so features are readily added and classes regenerated.
--
Posted By John Pritchard to
Gap Data at 11/02/2009 09:01:00 PM