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
