[racket-dev] Dracula development

Short, short version: I will be working on a new Dracula implementation;
see https://github.com/carl-eastlund/dracula (currently just a bare Racket
fork).

====

Short version: While the "new Dracula" is still spiritually "ACL2 via
Racket", the new one will be very different from the old.  It will be much
more Rackety, have full use of Racket macros and modules, and have a much
improved component system based very closely on ML functors.  It will also
be distributed as a regular collection rather than as a planet package.
Along with Dracula development, I will "spin off" some of my support
libraries as new collections (or parts of existing ones).

====

TL;DR:

The implementation of my thesis is "almost ready for prime-time".  I want
to push it out to the world soon.  I have not found Planet to be an ideal
platform for an internal PLT developer trying to keep up with the
development branch; I need to update my code far too often, and yet for
clients I have to maintain compatibility with the released version.  I
could probably resolve that if I wanted to maintain "stable" and "release"
branches of my own project; I do not.  Our organization has a whole
development and release infrastructure built around our core repository,
and it has not been beneficial for me to work outside that for so long.

In the meantime, my private Dracula development has built up a number of
support libraries.  Some of them are superfluous and should just basically
be "inlined" into the implementation, but some are also near-ready for
release in their own right.  The top candidates are my debugging library,
which is in the spirit of unstable/debug but significantly improved, and my
pretty-printer which has a number of advantages over racket/pretty.  I have
found both of these to be immensely useful in debugging programs with
little errors buried under huge amounts of data.  I don't know if the
unstable collection will be part of the life cycle for these collections;
I've yet to pin down the best way to use unstable so it doesn't just turn
into a code graveyard.  Probably these collections are better candidates
than some of my previous attempts, in that I am actively developing them
for a specific purpose and intend to push them out as stable collections
before long.  In previous cases, I was just putting stuff "out there" and
"seeing what happens".

The old Dracula was a Racket model of ACL2: taking ACL2 programs, and
simulating them in DrRacket so we could get the world teachpack and syntax
checking.  The new Racket is an ACL2 model of Racket, designed to be much
more along the lines of taking first- (and possibly second-)order Racket
programs and certifying ACL2 models of them.  I don't know how precise that
will be; the new ML-like components don't look much like anything we have
natively in Racket.

Anyway, the repository is up on Github, linked above.  Right now it's just
a copy of plt/racket, but I'll be gradually pulling pieces of my private
Dracula repo (which for various reasons I prefer to refactor into the
Racket fork piecemeal rather than copy wholesale).

Carl Eastlund
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.racket-lang.org/dev/archive/attachments/20120924/09c6fc9e/attachment.html>