| The Casbah Project: APIs and Reference Manual: Developer's Release 1 | ||
|---|---|---|
| Prev | Cardamom: Casbah Multi-Language Support in Java | Next |
We need an interlanguage calling protocol, perhaps modeled on parts of LDO. Certainly there needs to be "high level" interface which abstracts over the JVM protocol and LDO.
The "ideal" is to get the convention/protocol straight and then integrate it into the Kawa framework so that new languages get it "free". But we also must allow JVM language implementations which aren't Kawa-based can use it. Thus, there would be two routes to Cardamom integration---porting to Kawa, or ad hoc support of the convention/protocol. In the short term, the latter is the heart of of Kawa/JPython integration.
We need to do our "proof-of-concept" language implementation. I take this as the test bed for the Kawa framework, to see if it suffices for our purposes. What is most at issue here is which language to do. The selected language needs to have the following properties.
it needs to be small so that it's achievable in a timely manner. We need a functioning implementation by the release of Casbah DR 1.0, even if it's incomplete/beta. One must be able to do useful work with it.
It must be useful. Redoing Scheme is pointless. Merely porting JPython is pointless (since we have JPython). We want our test to be useful both for us and for others. It's only by being useful for us that it advances The Casbah Project, and it's only by being useful for others that we'll attract interest and, thus, assistance.
Obviously, the prime candidates are Tcl, ECMAscript, and Usertalk. Tcl will probably involve a port from Jacl. ECMAscript involves taking over the work Bothner already has already done on ECMAScript-on-Kawa. Usertalk is the "from scratch" option (which is fine, given its simplicity).
We need, and we shall, evolve the Kawa framework (probably in coordination with Bothner, but perhaps we'd want to fork it). This involves everything from tweaking/patching the Scheme implementation, to adding the interlanguage calling conventions, to whatever else we need.
What's nice about this structure is that it's both modular and synergistic. Each part can be worked on independently (rather, has subparts that can be worked on in isolation), but they feed into each other in clear ways.