Current Project Status
Esko Luontola
making all communication public, even before there are any external
contributors, I'm starting to post status updates here. For now this
will be a monologue, but you can never know when things will change...
Right now Dimdwarf is undergoing an architecture change, as outlined in
http://blog.orfjackal.net/2009/06/new-architecture-for-dimdwarf.html The
old architecture was written inside-out and the new architecture is
being written outside-in, so at some point the new and old code will
meet each other, but that has not yet happened. I've thrown away the
implementation for the old garbage collector and I'll also be throwing
away majority of the database and task scheduling components, because
they will be implemented quite differently in the new architecture (and
I didn't like those GC and task scheduling implementations anyways -
their design was far from elegant). Coding with the delete button is fun. :)
Following the ideas in the "Growing Object-Oriented Software, Guided by
Tests" book, all new development is done outside-in, starting with
end-to-end tests. The end-to-end test infrastructure is already in place
and working. It launches the server in a separate process, the same way
as will be done in production. The walking skeleton is still quite
limited - it does not contain all the main pieces and external systems
of the new architecture - but it's getting there piece by piece.
Next I'll be working on the communication layer, which uses
Darkstar/RedDwarf's SimpleSgsProtocol. I'll also try to put together the
main pieces for the new architecture soon, especially the controller's
main loop and message passing infrastructure. I will be writing those
parts in Scala, because of its nice pattern matching features.
Before starting to use Scala in this project, I might first finish the
Specsy testing framework (http://github.com/orfjackal/specsy) which I've
been writing, because in a recent project I was not quite happy with
Specs (it has too much complexity and bugs to my taste).
It's possible that in the autumn this project will be worked on in the
Software Factory Project at the University of Helsinki
(http://www.cs.helsinki.fi/group/swfct/teaching/swfactoryproject/index.en.html).
Nothing has yet been confirmed, but the course's coordinators have been
very positive towards the idea. We'll know more towards the end of
August, when the enrollment to the course begins. (Software Factory
"exists in singularity" - there is not past nor future, but all
decisions are made in the current moment. ;)
Before the Software Factory Project begins, I'll try to get the main
pieces of the new architecture in place, so that it will be easier for
the students to get started. These "main pieces" will probably include:
controller main loop, message passing, in-memory database, basic task
scheduling, basic client session communication. Then it should be
possible to run simple applications on the server, after which the
development can continue on to: sample applications, mocking framework,
database garbage collection, channel communication, on-disk persistence,
clustering, cluster management, dependency injection for applications,
database refactoring etc.
--
Esko Luontola
www.orfjackal.net