Kimwitu: what is it?
Let's have a look at our abstract...
The Kimwitu system is a meta-tool that supports the construction of
programs (tools) that operate on trees or terms.
The system supports open multi-paradigm programming, in that it allows
to express each part of an implementation in the most appropriate language.
Terms can be implemented in a tool as well as exchanged between tools.
In this way tool integration is facilitated. Experience has demonstrated
that Kimwitu drastically speeds up development time, facilitates tool
integration and generates production quality programs.
- a tool to build tools (like the kimwitu compiler itself)
- input: definition of data types, and operations on them
- output: C code (standard routines and translation of the input)
that can be used as 'custom-made' programming library
- programs (tools) that operate on trees or terms
think of language-based tools, such as compilers, editors, debuggers, simulators, testers and verifiers.
such tools have in common that they operate on trees or terms (DAGs).
- offer escape hatches to other implementation techniques (mix with C code)
examples: mix with X-Windows (GUI), Yacc/Lex (parsers), socket-based services
- it is possible control/override generated code (eg. memory management)
(using C preprocessor macro's to control the default behaviour of
Kimwitu 'system' routines, or even to override them by alternative
- multi-paradigm programming
allow to express each part of the implementation in the most appropriate language:
- a high-level one where possible (based on eg. attribute grammars, or functional languages, rewrite rules, unparse rules)
- a low-level one where necessary (eg. C)
- most appropriate language
the language based tools mentioned earlier are typically implemented
To bridge the gap:
- in high-level languages,
based on eg. attribute grammars, or functional languages
fine for prototypes, may have unsatisfactory space and time performance.
- in 'low level' languages, such as C, which offer total control.
disadvantage: large gap between
the description of the functionality and its realization
- high-level specification of data structures and operations on them, but
- allow low-level implementation directives (be 'open', as discussed above)
- terms, implemented in a tool
Kimwitu offers unparse rules, rewrite rules, and the use of pattern matching
in functions over terms
- terms, exchanged between tools
Kimwitu generates functions that read/write terms from/to files
- tool integration
- use a single, shared, description of the abstract syntax
of the 'interface object' as a Kimwitu input file.
- reuse this description for each tool, and use the read/write
functions to read/write the interface objects
next overview up