Deftly-woven abstractions; or Hacking one's way through life
Welcome to the page hidden under the colon!
Congratulations on your perspicacity.
As a reward, I will now proceed to bore you to death
with a rambling autobiography and some
philosophical musings, written in the
style of Julius Caesar's Commentaries on the Belgians.
Peter Van Roy was born in Rotterdam, the Netherlands. Despite this
minor anomaly, he is a citizen of Belgium, to be precise, of Flanders,
le plat pays qui est le sien.
He is obsessed with tinkering, having started with Legos at an early
age. He moved on to the Raytheon Lectron series of electronics
building blocks, and then started soldering together his own circuits.
He became a big fan of Low-power Schottky TTL with plug-in breadboards. His first
computer experience was at the age of twelve in summer school in Van
Nuys, CA, where he learned to program a Monroe desktop calculator and
to write Waterloo Fortran IV with mark sense cards and #1 pencils.
The heady smell of freshly-inked IBM listings still makes him nostalgic.
A few years later, in 1975, the MITS Altair was featured in Popular
Electronics. Peter got into microcomputing with the Netronics Elf II,
which is based on the RCA CDP1802 processor.
He added hardware multiply-divide and a random number generator to
this machine, cranked up the clock (to a whopping 5 MHz) and
wirewrapped 48K worth of dynamic RAM (big enough for anything in those
days!). Meanwhile, he had become interested in fractal geometry,
through Martin Gardner and Mandelbrot's 1977 book. In 1980 he built a
Forth compiler for the machine, which marked his departure from
hardware into software. For his engineer's thesis in Brussels he
designed a hybrid of Forth and Pascal, the Interactive Extensible
language Inex, and built a compiler for it in Modula-2 for the
brand-new MC68000 processor. In 1983 he went to Berkeley, discovered
the Prolog language, and built a compiler for the PLM Prolog machine
in Alvin Despain's group. This was the first published compiler
based on the Warren Abstract Machine (WAM).
At this point the Macintosh was first released and
offered at a discount to students. Peter returned to Belgium for
his military service, and in his free time started building
FractaSketch on the Mac. Back in Berkeley, he continued working on
Prolog and FractaSketch. He founded Dynamic Software with Bernt Wahl
to distribute FractaSketch and related tools. He finished his
dissertation on efficient Prolog compilation in 1990 (which can be summarized
as: how to get a Ph.D. with a factor of three) in which he built a
compiler for the VLSI-BAM processor. Then he went to DEC PRL in Paris where
he helped build Wild_LIFE, a system based on Hassan Ait-Kaci's LIFE
language, an elegant generalization of Prolog. In 1992 he released
Wild_LIFE 0.91, the first usable implementation of LIFE. On April 1, 1993 he
released Aquarius Prolog 1.0, which marks the end of an evolutionary line
for a certain class of systems (native-code Prolog implementations).
It is a tour de force that shows that Prolog can run as fast as C.
In August 1994, he was invited to New York to speak at a fashion show
by Jhane Barnes, a clothing designer who used some
FractaSketch images in her new line of men's wear. Upon the demise of
DEC PRL, he hopped to Saarbrucken to work on the Oz system in Gert
Smolka's group at the DFKI. This group's work, concurrent constraint
systems, is the future of logic programming. He is now working on an open
transparent distributed implementation of Oz that completely abstracts away the
network. During his free time he has added color to
FractaSketch, using a technique he devised
to color self-similar fractals (pat. pend.).
It seems that finally for him the Past is Prologue.
What he likes about CS and science in general is the fact that it works.
It lets him build arbitrarily complex constructions, limited only by his
tenacity and by what the system has assimilated in the language and its libraries.
It lets him play the role of the man behind the curtain.
Pressing the button makes it all run by itself as if by magic (barring bugs :-).
Another thing which intrigues him is the phenotype-genotype difference,
or the sealing off of levels of abstraction. Thousands
of lines of intricate code can lie under the surface, yet the system
is based on a powerful abstraction and its behavior is clean and simple.
For example, he is now writing a large asynchronous concurrent program
in the beautiful and simple notation of Oz.
This would have been much harder just a few years ago,
using monitors and semaphores,
and practically impossible before that.
One of the reasons he likes languages such as Prolog, LIFE, and Oz,
and design tools such as FractaSketch is the tension between
a simple, powerful abstraction and its complex implementation.
To make the beasties work well requires
some quick-stepping behind the scenes.
That's what drives his research: how to maximize the
power of the abstraction while keeping it efficient.
He is now working on record constraints, transparent distribution,
and seed-based graphic design,
three very nice levels of abstraction that require a beautifully intricate
woven structure underneath.
FractaSketch is particularly interesting because it
has the woven structure at two very different levels.
First, its simple user-level concepts are implemented by
the arcane commands of the C language.
Second, its intricate designs are based on simple seeds
that the designer creates.
The simplicity of the middle fans out to complexity on both ends.
Copyright 1995 Peter Van Roy.