Programming Language Design and Implementation
This page basically gives a historical overview of all the
programming languages I have designed (and sometimes implemented)
over the years. Some of them, notably
E,
False,
Bla,
Aardappel and
SHEEP
have their own pages.
At the bottom of this page there are some programming language links and other goodies.
Language Design history & overview
(chronological)
- MPL (1987, C16)
-
My first ever compiler (on the Commodore 16) implemented a tiny low level language
(a mix between asm & basic) and compiled to fast executable 6502 code.
The compiler itself (written in basic, terribly slow) was two-pass, and
used a strange job-code language for code-generation.
- Dex (90/91, amiga)
-
A non-recursive pascal/C mixture, precursor to E. Implemented by
a two-pass compiler (in gfa-basic, very slow), used extremely ad-hoc parsing techniques.
Generated quite fast 68000 assembly source (a68k & blink used as backend).
Got an article in the german "AmigaPlus" magazine. See a sample session
with the compiler compiling HelloWorld:
PROC main()
WRITE 'Hello, World!\n'
ENDPROC
E (end 91..97.., amiga)
Started out as enhanced Dex, ends as C++/Ada type language with functional features.
Implemented in pure 68000 assembly (extremely fast) as a one-pass compiler (plus one lex-only pass),
again uses job-code language for code-generation. Generates 68000 executables straight away.
Has been and still is a huge success: have a look at E homepage.
PLX (may 92, msdos)
A procedural language with lisp & logic features and uniform square bracket syntax.
Implemented as interpreter (in quickbasic, slow), again very unconventional parsing, lists stored as strings.
Yax (end 92, amiga)
A procedural beginners language with lisp-like syntax. Implemented in E as interpreter,
uses same lex-pass techniques as E compiler. Just had one very fanatic user (Ben :)
(defun fac (n) (if (eq n 1) 1 (* (fac (sub n 1)) n)))
NGRC (jan 93, amiga)
A special grammar formalism with features for generation & randomness (music oriented),
implemented in E as a compiler to protracker modules.
mynote -> { 10 [D,2] | 1 [D#,2] | 1 [Db,2] };
Aaargh! (93)
A complete E redesign. more orthogonal, more functional, different syntax,
full pattern matching, lists/gc/TI etc.
map f [] = []
f [head|tail] = [f head|map f tail]
False (march..may 93, amiga/unix)
A very cryptic but very pure Forth type language with anonymous function blocks.
Implemented as compiler (<1024 bytes 68000 exe) and a portable interpreter in C.
Was moderately succesful. See the False homepage.
[$1=$[\%1\]?~[$1-f;!*]?]f: { fac() in false }
Blerk (nov 93)
the very basic semantical foundations of Bla (1st class environments
as objects/functions) all
present already here. rest of the language (syntax + semantics) very primitive.
stack {
private top = 0, data:list;
pop { [ data.get(--top) ] };
push { public val [ data.put(val,top++) ] };
[self]
};
Blerk was supposed to have user definable syntax. All
language constructs would have the same term(a,b) syntax, and on the fly
macro/grammar-rules added any possible syntax to the language.
Normal keyworded syntaxes considered as well.
OOHNO! (jan 94)
Fundamentalistic dynamic delegation OO language. very primitive, small
language core. very "Self"-like.
stackt <- push (method# <- new);
(stackt push) :: [
elements write top new;
top += 1;
];
BRAAK
Forth meets Prolog: stack language that uses unification to retrieve
values from stack instead of push/pop, or Ordered Unification Spaces.
append:[ O L L <=> nil O ]
append:[ O H:T T O append X H:X ]
GRRR
Actually various designs in one, all based on term/tree-rewriting / equational
logic. meant also as compiler toolkit. many evaluation strategies
considered.
_:E' = S:E
_:E'' = stats(R):E''
=====================
stats(S:R):E = []:E''
[lazy_generators] (jun 94)
Reinventing the wheel: the deforestation optimisation for lazy FLs. uses
composable generators ipv interim lists.
G (aug 94, amiga)
Graphical dataflow language. details various forms of efficient non-concurrent
evaluation, and various DAG layout algorithms, possible type-systems etc.
Also ascii syntax design without identifiers, and how to
how to enhance compositionaly and reduce dependancies between software
components (not overly succesful). OO variants considered.
A prototype implementation (a dataflow editor) was started.
 
X780040 (end 94)
General low-level virtual machine design, meant to support both Bla and Plop,
and anything else.
Bla (end 94, unix/amiga/...)
An unpure functional/OO language, strong typing + TI (makes the ideas
already present in Blerk into a solid and usable design). Implemented in C++ as
a compiler to portable bytecode (the Emmer intermediate language) which
could then be interpreted etc. After the initial paper end `94, Bla was
fully developed and changed quite a bit during almost all of '95. Have a
look at the Bla homepage .
GRR (jan 95)
Term rewriting language meant as language implementation tool, featuring
higher order patternmatching that can be used both as grammar (parse+lex) and
transformation/generation. (related to GRRR). (see an
example).
Ni! (feb 95)
Study on polymorhism, and how a system based interfaces and certain
compatabilities between them should be more powerful and compositional than
OO.
UH (feb 95)
1st class concurrent bags. Linda meets Actors meets BRAAK.
{
numphil:5
---
c c eat:P => ok->P.
numphil:X>0 => numphil:X-1 c room:*->{
hungry
---
hungry `room:R => eat:*->R.
ok `room:R => c->R c->R hungry.
}.
}
UHH (mar 95)
Programming by example using bags.
[growing_example_stacks]
Trying to reduce the visual complexity of VPLs: using stacks with example
values in them.
[inheritance_harmful]
Functional alternative to OO: uses compositions of terms and delegation
relations between them, and transformations instead of patternmatches.
(related to Ni!)
Point = Loc:Col(c) {
Inverse Point(c=C) = Point(c=256-C)
}
Apfelstrudel
Unites all previous VPL layout methods into one semantical framework
with possibly different representations.
GRMPF
A purely functional language with novel syntactical constructions to
make programming more practical in context of ADTs etc.
pop(pop(s):a):b
[no_methods_oo] (jun 95)
An OO language that uses just reading/writing/creation/deletion as messages to
an object.
Kartoffel (nov 95)
Uses a system of higher order functions similar to Backus' FFP language
to create a visual language. layout is purely composition of boxes into
bigger boxes. "Kartoffel" is the ascii version.
Sauerkraut (dec 95)
A completely different attempt at a VPL: using term-rewriting
and bags, and a new evaluation scheme. (related to GRRR, GRR, UHH, UH)
Schnitzel (jan 96)
An even simpler design for visual programming based on Linda tuple-spaces.
looks even less like programming.
[fundamental_reuse]
On how reuse works and why the traditional ways of doing so
(including OO) don't work.
BRAAF
Computing with single-value objects that trigger bits of code upon
reading/writing.
[principles, bags] (sept 96)
Sums up some of my general language design principles, and explains
why the various languages below based on Schnitzel and Sauerkraut are
so great. Deals with "Reducing the Complexity of Dependancies".
Schnitsauer (oct 96)
Attempted to combine dataflow and Linda into a general visual concurrent
component type language. made to be very compositional and flexible, inspired
on Schitzel.
Sauerkraut II (nov 96)
Extends Sauerkraut with dynamic contexts to match onto.
[alt_pattern_match]
Shows a syntax to have left and righthandsides of rewriting as one huge
expression, and some various weird ideas.
#:append([],*)
[#:append([*|T],Y)|append(Y,T)]
Aardappel (nov 96)
(previously known as "Hekking" and "Sauerkraut III").
Does the obvious thing and combines the ideas present in Sauerkraut I, II,
Schnitzel and SchnitSauer to come up with a "Concurrent Tree Space
Transformation Language". Does visual tree rewriting with Linda type
concurrency, transformations (i.e. linearness + object identity) and other
neat things. Design has been polished a lot during '97.
(see its own homepage)
Boerenkool (oct 97)
Another design for a graphical programming language, this time
based on tree structures with clever tricks for sharing, and
programming by example. Has now been integrated as the syntax part
of Aardappel, but idea can be applied to a whole class of (funtional style) languages.
Here is the full picture
DaMaul (sept 98)
A very minimalistic "chemical reaction" type language in the same family as Linda & Gamma.
The only language construct left is the "communication" which react in pairs.
Aardappel [optimized] (jul 99)
Simplified the original language greatly by removing function values (these can
be expressed in the language itself using specificity ordering).
(details here)
UhOh (oct 99)
A cross between Monads, Backus' FFP, and my Ni! and Kartoffel languages. Uses
a friendly version of Monads layered into FFP's higher order functions to allow
for easy (compositional) state, io, exceptions etc., in a referentially transparent language.
WadC (dec 99)
A cross between a very minimal lazy functional programming language and a macro preprocessor.
Used as the language to program 2d line structures with intended as maps for the game Doom.
(more here)
Sheep ["hardcore" version] (jan 2000)
A fully linear (one reference) referentially transparent strict functional language with
inclusion polymorphism and easy usage of state & OS. Designed to be implemented to
allow for an extremely high level of optimisation (no
garbage collection, no aliasing, only in-place update, specialized dispatch).
SHEEP (feb 2000)
New scripting/querying/ipc/programming language I'm doing for Amiga Inc., with as
basis a not as hardcore version of Sheep. Expect familiar beginner friendly syntax and semantics
coupled with multimethods, automatic memory management without garbage collection (linearity), powerful
datatypes, pattern matching, strong and dynamic typing living together in harmony,
integrated access to all the new Amiga OS features, and optional compiled output comparable to C in speed and size.
More here.
Goat (april 2000)
Specialised language that can specify binary (file) formats & possibly transformations on them, from
which a variety of translators, converters, browsers, editors etc. can be automatically generated.
[feedback_trigger_VPL] (may 2000)
A graphical programming language based on (cyclic) dataflow, which embeds state into the
dataflow, making for natural definition of "objects", better code sharing, clearer dependencies, good seperation of
core & peripheral methods, and reduced dataflow connections. Easy "environments" and lambda objects.
See a mockup for a stack ADT here.
PIG (oct 2000)
PIG is an "anti-functional programming language", an experiment to see how far one can get in a language
which only has global state (in the form of stacks) and argument-less functions. Inspired by OpenGL and the "move" cpu.
[linear_lazyness] (dec 2000)
An investigation into the interactions between linearity and lazyness, and possible optimisations.
COW (june 2001) COW is another
"environment" language like Bla, but is much more radical in unifying all
possible programming language constructs into one (the environment). Extremely
tiny language definition covers classes, objects, modules, functions/methods
function-environments, scopes, (recursive) lambda's, tuples, lists, arrays,
monitors, futures, bags etc. etc.
If you look through the list, you'll notice that many design relate to eachother
and that there are many reoccuring themes. In this respect, the Aardappel/Boerenkool
designs finally put together something that was latent in many previous designs.
Implementation wise, besides the implementations mentioned in this text I have made
loads of implementations for existing languages, in particular all sorts of Lisp,
ProLog, Lambda Calculus and Tree Rewriting variants.
Here's my programming languages bib file.
|
