Everyone’s been waiting patiently for Hedgehog. There’s no way to know when the next step of David Reed’s Tea Time will be available. As David Smith and Andreas Raab began working on Simplified Tea Time for Hedgehog, there was no way to know when that process would produce results.
The Croquet group at the University of Wisconsin is not in the Computer Science department. We’re not driven by the theoretical concepts of Croquet for its own sake. We are in the Academic Technology department of the Division of Information Technology, and our interest is in building educational applications in Croquet. Adding stuff to the Croquet core is fun, but what we really need is to build learning environments with faculty. Last summer, we had the opportunity to just that, and we took it, even though we knew that the existing Jasmine proof-of-concept version of Croquet would not meet our needs. What to do?
We took two tracks. We had a seasoned applications developer (Jack Keel) who had been working with Jasmine and it’s predecessors since before I had even heard of Croquet. We paired him with an art/math/comp-sci student (Kael Greco) to build the learning environment within Jasmine. It was painful. Everything to be present had to be instantiated and positioned programmatically by Jack (who was working half-time on the project). With everything going through the programmer, the turnaround for faculty, instructional designers, project managers, and artists was so slow that one project observer decided against pursuing another potential Croquet learning environment project.
In the second track, we put two developers (myself and Josh Gargus) and an intern (Martin Schuetze) on developing a successor to Jasmine. We needed a version of Croquet in which users could enter and exit the collabration at any time, and in which these users could interactively introduce and edit objects within the environment as they used it. It would also help the cause if these users could be located on different subnets (i.e., anywhere on the Internet, rather than just in the same room).
During the summer, Andreas had done some experiments with using the Island concept from his Tweak programming system. The idea was to use this as a clean container for a unit of collaboration, and this is exactly what ended up happening for Hedgehog. By October, Andreas and David Smith had created the core replication model for Hedgehog using Islands, but they had not made the Croquet objects render or handle events through the model. How long would it take them to get this done? No one knew. Andreas suggested a hybrid approach for us: build our learning environment in two parts. There would be a replicated model that used the Simplified Tea Time replication architecture. This would drive and be driven by a non-replicated view of the model that used ordinary Jasmine, and which ran outside of the Island. At first I though this was unnecessarily complicated, and tried to put the whole Jasmine application inside an Island. The problem is that for Islands to do their job, one needs to be very careful about communication from the Island to outside, and particularly from outside to the Island. Some messages need to be replicated on the network so that all participants see the same results, while other messages (like those involved in rendering) do not effect the results and so need not (and sometimes should not) be replicated on the network. I started untangling the web of references between the Island and off, and got as far as being able to render from an Island model as long as it had no interaction with the user. I eventually realized that I could not predict how long it would take to unravel this web completely, and that indeed, David and Andreas were completely rewriting the rendering and event code to deal with this very issue. So we finally took Andreas’ suggestion. In a few weeks, we had a working Croquet with persistence and the ability of users to come and go at any time. We also took David Reed’s Virtual Peer-to-Peer Private Network code and adapted it to the Simplified Tea-Time replication architecture. This allows us to coordinate worlds from any ordinary user machine (even behind a firewall and without a fixed IP address).
Finally, we have a pretty nice user interface, in which any user can interactively create their own world, or rooms within worlds, and any network of portals between. Users can bring in 3D meshes and 3D textures, and Web pages, and sounds and Flash animation. They can create their own text and cubes. All of these can be reproportioned and positioned and aggregated into assemblies. (E.g., you can define your own bricks and build walls out of them.) It doesn’t have Brie, but it does have some of the feel of Brie in having assemblies and in being to pull some specific behaviors (sounds and textures) from out of one object and putting them in another. And you can freely copy everything and move stuff between worlds.
We called this Dormouse, and there is some more description here.
It took half an hour to manually recreate the final version of the learning environment within Dormouse. Of course, Jack and Kael and the other project members had already done all the heavy lifting of creating the 2D and 3D artwork and deciding how it should be arranged for flow. So Dormouse now has a private persistent home world for each user, with a portal to a common world. The commons has a portal to this learning environment, and to others.
There are a lot of user interface elements in Dormouse that I think will probably not be in the first version Hedgehog. So, we will continue to develop this project in Dormouse, and then move it over to Hedgehog when Hedgehog is rich enough.
We will not be releasing or supporting Dormouse. From day one, Hedgehog will always be more robust than Dormouse. (Dormouse is not bad, and much more robust than Jasmine because of the new replication architecture. However, it still contains all the old Jasmine code for rendering and events, and it still has all the old-but-now-unused “meta” code for collaboration.) And Hedgehog will eventually have all the features of Dormouse, but implemented more cleanly.
So what good was this Dormouse work? There are a couple of conclusions to note. One is that even before the release of Hedgehog, there is already a learning environment for classroom use that uses its architecture for coordinating collaboration. The application works, and it’s cool. The underlying collaboration architecture works and it’s cool.
For a long time, the Croquet project was dependent on David Reed’s progress, but Hedgehog changed that. During the early development of Hedgehog, the project was dependent on David Smith and Andreas Raab. Although everything in Dormouse was invented by one of these three guys, it was developed by a larger circle, and largely independently (i.e., I don’t think we pestered these guys too much). By developing Dormouse, we have illustrated that there is now enough “there” there such that this project is now viable on its own. This is very good news for the now-forming Croquet Consortium.