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 implementations)

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

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

To bridge the gap:

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