Eidola status and plans

Eidola Status and Plans

Home

What's done: I have a young but solid form of the static (i.e. non-runtime) semantics for named elements (packages, classes, variable and functions). Read and enjoy! Several unresolved questions have surfaced, and need your input.
Current work: It's time to start describing what's inside a function. I'll begin with begin with local variables, class member access, function calls, and assignments. Developing the algorithmic, scoping, and runtime semantics for these few constructs will actually cover most of the major big holes remaining in the semantics. The section on scoping is in an early draft form, and needs a lot of work. It will iron out as the algorithmic semantics take shape.
Coming soon: The current document on the semantics is really intended as a reference document -- it tells what is part of Eidola, but not why. I would eventually like to explain some of the reasoning behind them, which will include a good deal of pontificating on object-oriented philosophy. This is currently taking a back seat to implementation and a desire to get started on notation, but I swear it will happen.
In the future: It would be interesting to study at some point the mathematical properties of the semantics, such as proving its consistency, or drawing illuminating correspondences between the semantics and algebraic structures like groups and categories.

Kernel

What's done: I have a working Eidola kernel in Java, covering the subset of the semantics which currently exists. It has an interesting heavily threaded event model, which solves the dual problems of lazy rule checking and user interface updating. Nick has verified informally but thoroughly that the the code, the javadoc, and the semantics all agree in their description of the language.
Current work: The current 0.0.0 release is solid enough for some serious peer review. Poke at it, test it, and give your opinion! I'd really like to do some systematic testing, and start building a standard test suite for Eidola kernels. Aaron has agreed to research this little project.
Coming soon: I'd like to do an aggressive search for corner cases, and use the kernel to discover and consider unexpected constructions allowed by the semantics. I'm taking volunteers for this! Work will begin before long on the semantics for scoping, algorithms and runtime. As these things start solidifying, the kernel will start implementing them.
In the future: Nick has suggested modeling the threading mechanisms to root out synchronization problems; this is a good idea if we can do it.

Notation

Visual representations of Eidola programs are still mostly pipe dreams. However, now that we have a reasonably stable fragement of the semantics and kernel in the 0.0.0 release, there's room to start experimenting. Notation work will run in four phases (each continuing even after the next has started):

Collect all sorts of notation ideas from all sorts of people, and compile them in a highly inspiration gallery on the Eidola site.
Try implementing some notations in a casual way, focusing more on getting stuff on the screen than on designing everything right.
Based on the experiences of 2, implement a general framework for building notations and making them play nicely together, this time focusing on doing things right.
Implement the best notation ideas from 1 and 2 using the notation framework from 3.

For phase 1, I am collecting ideas for the notation gallery. Send yours! Attention non-programmers: you can play this game too!
For phase 2, I am implementing a few toy notations just to get the ball rolling, but not coding anything terribly serious.

Mission-Critical Eidola

Nick's argument for the importance of MC Eidola is now available, and highly recommended!
The special mission-critical version is a long way off; however, the issues that Nick raises are informing design in other parts of the project. I have created the mission-critical section of the site in anticipation of future work devoted particularly to MC Eidola.