Wed Jul 2 22:13:52 CEST 2008
1. Practical: Build a framework for metaprogramming (multi-stage
programming) in 'lisp-and-forth-style'. This is taken to mean the
design of a programmable compiler for 2-stack machine models in a
clean dynamic language. This goal is reached through the use of a
purely functional dynamically typed stack language, and implemented
in a Scheme extended with a hygienic macro system that works well
with modular code development. (PLT Scheme's macro system).
This framework is supposed to get practical issues out of the way so
an intuition can be built about Resource Aware Programming (RAP)
centered around metaprogramming of 2-stack machines. Note that there
is not much new here: it is merely a combination of existing ideas
(Forth, Joy, Scheme) into a coherent system.
In Staapl there is a balance between a static and a dynamic approach;
this according to / borrowed from the PLT Scheme tradition: a static
hierarchical module system for large scale code management, and
dynamic interactive compilation, incremental code upload and target
interaction. The concrete target architectures are small
microcontrollers and DSP processors. The core could be called a
dynamically typed, concatenative macro assembler (CMA).
The basic framework is as good as ready. There is a single test
backend for Microchip PIC18, and some bits and pieces for a C code
generator. Most changes in the last year were about implementation
and simplification: better integration with the PLT Scheme macro and
module system, and simplification of the low level language model to
eliminate ad-hoc non-composable constructs.
2. Experimental: Design DSLs for resource (time/space) constrainted
programming on top of the concatenative macro assembler idea.
Currently, there's Purrr, a Forth dialect, and Coma, a cleaner
s-expression based concatenative Macro language used to implement the
purely functional core of Purrr. Future work is mostly about program
transformations (fusing/deforestation/...) in a Backus' FP and related
"Algebra of Programs" framework, OBJ's "theories", and a look into
typed staged systems ala Taha's RAP research. I am also interested in
parallel programming, trying to figure out a way to marry process
calculi with the 2-stack machine model.