Oxford, 31st October 2001
Quite a few people have signed up to the mailing list, and a few more have offered input and/or
Mark Utting said:
> It sounds like a great idea, and one that I'd like to be involved in.
>(Actually, my thought is: Why didn't you (or someone) suggest this
> a year or two ago!).
Hmmm. Mark has been looking at Zeta, and judges it promising as a basis for CZT (see below).
The team at Pernambuco (Ana Cavalcanti and others) have some prototype Z tools written using Java, including a parser meeting most of the Z
standard (though operator templates are a challenge).
Jonathan Bowen is working on a grant proposal to do some research, with tools as a component, and might be able to contribute effort to the
core tools development as a result.
Here are some themes emerging from people's messages:
- Let's register CZT as a project at sourceforge.net. That seems uncontroversially
a good idea.
- On the licencing front, it seems best to let people do whatever they want, but with anything that is to be `core' being open source
and free for most (all?) uses. That probably means a choice of GPL or BSD-style.
- Implementation languages are going to be quite an issue. Part of the goal is to
produce something durable and portable, so it needs to use common tools
(Java, XML) not exotic ones. On the other hand, many people's interest
will come in interfacing tools together, so the ability to interoperate with
many other languages is crucial.
- As Roger Jones remarked, this is looking more like a programme of work
than a single project.
Several people have remarked that it is hard to find funding or motivation to
build the core tools; this not being real research. However, many more
open research projects need tools, and an open interoperable framework seems a
good way to provide this. If we can avoid duplication of effort, we may
make everyone's research more accessible and/or easier to apply.
Zeta seems to be a very strong
candidate for a starting-point. Its main drawback (from the point of view
of durability and portabilitiy) is that it uses Pizza, a neat extension to
Java. Pizza support has only recently re-emerged, and it is not yet clear
if Zeta compiles with up-to-date tools. My proposal is that this
should probably be a starting point for CZT, with a plan eventually to
re-implement its key features using plain Java. A design for the CZT core
could be reverse engineered from Zeta, so that there is a working prototype, but
ultimately something else emerges. I've no idea if this is feasible; I
haven't had time to look at Zeta myself yet (see below).
Another key for interoperability will be an interchange format. The Z
Standard was going to define an SGML mark-up, but life has moved on.
An agreed XML form (taking elements of the Z/EVES format, maybe, and based on
the Singapore - Jin Song Dong - work) is needed. Tools to support
transformation between all the widespread mark-ups would be useful (again, Zeta
provides a good start, I think).
Next steps: workpackages
I have to admit that the complexity of trying to manage this effort is
beginning to dawn on me... The way ahead is not clear enough yet to permit the
definition of a detailed workplan, though even the simple workpackages below
have several dependencies between them. There seems to be substantial
interest in making CZT happen, and I am keen that people should feel progress is
happening at an appropriate rate. Suggestions are welcome.
I'd like to propose the following work-packages. Please write to
the mailing list and (a) redefine them (b) add others (c) propose to undertake
one or more.
- Register CZT at sourceforge.net. [I guess this one is up to
- Make Zeta work with current versions of Pizza, and Java 1.3.
Document the configuration/baseline, and check the relevant material into
- Collect and classify an extensive list of requirements for the CZT
core. [Probably a team activity.]
- Evaluate Zeta as a prototype for CZT. Write a report.
- Evaluate XML mark-up proposals for Z. Write a report.
- Write a design for the CZT core tools. This will need to be
undertaken by a small group. Volunteers?
- Evaluate methods of integrating diverse tools with this kind of
framework. How easily can the Java data structures be made available
to Haskell, SML, Prolog, etc.? Is a loose coupling (via a file in some
interchange format) the best that can be achieved, or is a Java front-end to
such tools practicable?
- Investigate cross-platform support (in Java?) for the Unicode characters
defined by the Standard. Produce an app(let) that displays some Z
graphically. [I've done this, but the cross-platform bit defeats me at
Mark suggested a CZT meeting at ZB2002.
I wasn't planning to attend; what do others think?