1.1 - December 2003 - Reed Hedges (reed @zerohour.net), Peter Amstutz (tetron @interreality.org) & Sebastian Malcolm (syb @xibarspace.net)
1.0 - March, 2002 - Reed Hedges (reed @zerohour.net) & Peter Amstutz (tetron @interreality.org)
In the Spring 1999 semester of our freshman year of college at the University of Massachusetts, Amherst, Reed Hedges was sitting in his dorm room trying to write a philosophy paper. Peter Amstutz, who lived across the hall, dropped by and Peter, Reed, and Reed's roommate Matt Barry began to talk about Linux and the Internet and Virtual Reality, as they often did. At the time Peter was in the process of reading the book Snow Crash by Neil Stephenson, and was extremely interested in the subject of VR. Peter had also been running his own IRC server (largely for the benefit of the residents of his floor) and proposed that they, the three hackers that they were, should write their own graphical chat program which would be "much cooler than IRC." From Stephenson they took the name Metaverse, and so the project was born. The "Metaverse" in Stephenson's novel was a global immersive multiuser 3D network. Soon Reed's philosophy paper was forgotten and the three were conversing and debating late into the night about how we would go about designing such a system.
Much later we discovered another program called Metaverse (later renamed to Openverse Visual Chat), which was written in TCL/Tk and was a simple system for 2-dimensional graphical chat (like the old Palace system.) Ironically, this program embodied most of what we originally intended to do, before we switched gears and began to work on a true VR system and not just as simple graphical chat.
(Reed) I found some notes from those early days. The original idea was to have a standard client/server architecture, and to limit the protocol vocabulary as much as possible, to try to express all the many actions that would take place in the Metaverse as simply as possible:
ACK
NACK
GET
SET
(Reed) At one point that was going to be our entire command set. In addition, someone had the idea to "push" or "update" clients with information that changed proactively. This is where the basis of the current properties seems to have originated. Later, we had the idea that the server would maintain a list of client addresses, and each client could read that list and send messages directly to another client to download model geometry and texture images directly. This way, the client would not have to upload anything to the server, and could change its attributes very dynamically. Hence, the distributed nature was introduced. Later, we realized we could do away with the "server" idiom entirely, with each object in the world maintaining all its own properties, and instead use the distributed tree structure.
When the project was still concerned with mere graphical chat, some prototype code was written in C++. It had no notable features (and probably did not do much of anything) and has been lost to the mists of time. A second prototype was later written in Java to experiment with some new ideas of redesigning the communications architecture to support peer-to-peer connections, bypassing the server. The second prototype successfully demonstrated a rudimentary ability to establish direct connections between clients, which could then send talk messages to each other. More flexibility in the system was needed, however, and so work was begun on the third prototype. This is when the project started to get serious...
By the fall of 1999, we had established the basic distributed-tree design. The fundamental notion of the system was a hierarchy of interconnected objects, where any given object could be located at anywhere on the network. Peter began to implement this design in Java, and we called our system MOS or the Meta Object System. Even at this early stage we considered MOS to be a general purpose architecture, on which the 3D VR application could be built. Objects now had a type (but only one!) and properties were a built-in part of objects. There were two kinds of connections with other objects: links and children. Objects could only have one parent, so each object had a unique path that could identify it. Each object had a tree of properties, and each property was made up of four fields: data, metadata, context and description. The underlying protocol was based on XML but only superficially similar to the modern VOS protocol. Children and links where analogous to the modern VOS's child objects, indicating edges in the distributed tree. While children composed a strict tree, links (which were one way) were allowed to cause loops in the tree. Public key authentication and encryption were built into the protocol. Reed also worked on documentation, and the OTD (Object Type Definition) format.
Early on we approached Brian Levine, an Assistant Professor of Computer Science who was interested in the project. He was able to support Peter as he worked for the Secure Internet Group Networking Laboratory (SIGNL) over the Summer of 2000. During the summer Matt (working for OIT) and Reed (unemployed) also lived in Amherst and continued to work on the project.
In Spring 2000 we presented our work, including a working 3D client, at the Undergraduate Research Conference in Boston, MA, and a thorough description and analysis of the design and implementation was written. The source code for the core library and various applications, including the 3D client (Metaspace), a 2D chat (gfxchat), and an instant-message application (MIM) was stored at Sourceforge.net, and a couple releases were made.
This code, as well as documentation, is still available at Sourceforge: http://www.sourceforge.net/projects/adr
We called the overall project Amherst Distributed Reality, which included the core MOS, as well as the various applications, and protocol development and documentation. By the end, the entire MOS project consisted of roughly 24,000 lines of Java code, and performance was absolutely terrible.
In the Fall of 2000, the MOS code-base was beginning to show some serious cracks. For much of that semester, Peter (who was taking an especially heavy course load at the university) had very little time to spend on MOS. Development largely stalled for several months. With the clarity of being able to step back and re-evaluate the system from a distance (or alternately, the horror of trying to understand a lot of really hacked up code written several months previously) we decided it was time for a major redesign.
During Spring and Summer of 2000, Matt had begun work on a C++ implementation of MOS. In Fall 2000, Reed also began writing his own version in C++ using some of Matt's ideas. In the Spring of 2001, Pete began a totally new C++ implementation, based on a significant redesign of the system. Reflecting this major shift in thinking, we called this iteration "third system" or S3, and the software was renamed the Virtual Object System or VOS. Part of the reasoning went that the previous Java implementation suffered from the affliction known in software engineering as the "second system effect". This happens when a designer has a little bit of knowledge as to how to design a system, and consequently over-designs it so that the result is overly complicated to the detriment of software quality. Some of the major changes differences between MOS and VOS included a change of implementation language (from Java to C++); the merging of the concepts of MOS "children" and "links" into VOS children; the idea that child objects should be ordered and multiple children of the same parent could have the same contextual name; a formalization of sites as peering points between processes; a vastly simpler mechanism for issuing updates by remote objects; and a complete removal of "properties" from the core object model in favour of using the new model of object children.
As of the time of this writing we are on our seventh public release and have attracted the attention of a small community of like-minded hackers. We have developed an Mp3 jukebox application, a simple hypertext application, a control shell "mesh", and a in particular 3D client using the Crystal Space 3D engine.
In the Spring of 2001, Professor Andrew Fagg became interested in VOS, and Peter implemented VOS on the Xybernaut wearable computer. One use of the VOS 3D application was to create a robot visualization tool. This was described in a paper presented at the 2002 IEEE International Conference on Robotics and Automation titled Real Time Visualization of Robot State with Mobile Virtual Reality. In October 2001, Reed also began working for Prof. Fagg and worked on some tools and applications related to wearable computing. In March 2002, members of the class on wearable computing began using VOS to develop a mobile augmented reality game.
We've come a long way in three years. Through its many incarnations, MOS/VOS has developed into something we think has a lot of promise as the basis for a variety of Internet applications. We are committed to building the most interesting platform we can, and supporting the development of creative and progressive communication tools for the Internet, through the development of open, patent-free standards backed by a Free reference implementation. We hope that our work is appreciated and more importantly genuinely useful for the intended application. We also strongly wish to raise interest in the academic and free software communities as to the usefulness of the tool we have developed. Finally, we hope others who find our work interesting will join us in our development. We welcome new code!
During the later half of 2003 it became apparent that the VOS code-base needed to support multi-threading for both Server to Client communications as well as event processing in client applications such as Ter'Angreal. The limitations of the S3 (single thread) design became very apparent when attempting to get Ter'Angreal to run correctly under MacOS X
Though not planning on a complete rewrite from scratch, Peter saw the opportunity to do some further cleanups of the VOS's design while making all the code thread-safe and implementing multi-threading.