Programming projects currently worked on
Most of my projects are hosted
at GitHub. I find their service
good. They allow for any number of free projects, and the price for
personal projects is quite reasonable.
SICL (which does not mean anything in particular; pronounce it as
"sickle") is a project that has two main purposes:
- Provide portable modules for implementers of Common Lisp systems
that provide some functionality that the Common Lisp language
standard requires, and that can be implemented using only some
other required features of the language without sacrificing
performance of the result.
- Use those modules plus some non-portable code to implement a
completely new Common Lisp system.
Some goals of the system and the individual modules are:
- Performance should be good; excellent if possible. Certainly
comparable to the best existing systems.
- The system should be well documented, but when it comes
to user documentation, i.e., documentation that the
application programmer might want in order to be more productive
in writing those applications, and when it comes to internal
documentation, i.e., documentation that might be useful to
someone who would like to understand how the system works, and who
might want to improve it in some way.
- The system should be highly introspective, allowing the
sophisticated user to inspect parts of the system with the use of
tools provided by the system itself.
- The system should provide excellent tools for debugging user
programs.
- The system should use internationalization so as to improve the
learning curve for non-English native speakers.
Internationalization would concern documentation, but also error
messages.
The repository on GitHub contains a document that explains the state
of various modules and the rest of the system, as well as plans for
the rest.
CLIMatis is an attempts to define a more modern and also a simpler
specification of the Common Lisp Interaction System (CLIM) as well as
a demo implementation of the new specification.
While we are very happy with the outstanding result of the work by the
programmers who
wrote
McCLIM,
there are unfortunately some vague aspects of the
CLIM II specification that make it quite hard to get good
performance of any implementation.
Currently, we have what we think is a sound low-level layer that is
fast and flexible. There is a single backend that uses a X11
image object as a frame buffer but that seems to be plenty fast
as long as the system is used locally. Other backends might be
required if the system is to be used remotely, but that is not even
clear, because we optimize screen redisplay so that only the parts of
the screen that change after each interaction is actually transferred
to the display server.
On top of the low-level layer, we want to put a simplified subset of
the features of
the
CLIM II.
Clobber is a cute little project that demonstrates the feasibility of
using in-core databases for the vast majority of information systems
that are used today. The project should be seen as a simplification
and improvement
of
CL-prevalence which is an implementation of a technique
developed for Java called "object prevalence", and which has been
implemented in the Prevailer
library. Clobber takes this technique further and gets rid of
snapshots entirely, which simplifies the system and which has the
additional advantage that the model classes can evolve without
making the snapshot or transaction log useless.
robert.strandh@gmail.com