An application generator (AG) produces applications from
high level specifications (See Figure .)
The specification is written in a
language that is likely to have powerful,
compact, domain-specific constructs; the application generator will
lex and parse this specification into an internal parse
tree representation; this parse tree will then be
checked for semantic correctness, consistency etc; from this
validated parse tree representation of the specification,
code is generated; this code can be linked up with
an architecture, library and/or run time environment
(which we collectively call a domain specific framework (DSF))
to implement
the application.
Application generators have become increasingly popular
in industry, particularly with the development of tools
to build application generators such as MetaTool [#!metatool!#],
CENTAUR [#!centaur!#]. Commercially
available tools such as MetaTool provide facilities for generating
parsers, built-in data structures that can represent parse trees,
and various traversal operators for traversing the parse tree.
MetaTool provides a ``template driven'' approach to code generation
that is particularly useful for code generation.
Newer tools such as CENTAUR
provide (in addition to parser generators) semantic
checkers that are driven by formal specifications.
Application generators improve productivity in several ways.
First, because of the power of a
well-designed specification language,
the size of a high-level specification to implement
a given application is likely
to much shorter than a corresponding implementation
in a conventional programming language. Secondly, a
high level of reuse can be achieved, more or less automatically;
the applications re-use all of the domain-specific framework.
In a recent survey paper [#!bigsurvey!#], Biggerstaff
cites some impressive gains in software productivity achieved
through the use of application generators.
There are hower,
some significant technical issues with application generators,
which form the main concern of my research and this position
paper.
Figure:
A Typical Application Generator
|