This document is also available in postscript form.

Plan of Study:
Exploratory Programming with Collaborative Programming Languages

Doug Orleans
131 2nd St.
Cambridge, MA 02141

Advisor: Prof. Karl Lieberherr


Exploratory programming is an important part of the software engineering cycle: when a domain is not very well understood or open-ended, or it's not clear what algorithms and data structures might be needed for an implementation, it's useful to be able to interactively develop and debug a program without having to go through the usual constraints of the edit-compile-run-debug cycle. Many languages provide support for exploratory programming via interactivity, dynamicity, and extensibility, such as Lisp, Smalltalk, Self, Obliq, Cecil, Dylan, and Python. However, most exploratory programming languages (and language environments) only allow a single programmer to interact with the code and data being developed; if a team of programmers wishes to collaborate, they must use project management and revision control tools which greatly discourage or hinder an exploratory style. What I plan to study is how language-level support for multiple programmers can enable exploratory collaboration.


My interest in collaborative languages stems from my extensive experience with muds. What started as a multi-user text adventure game in 1979 has evolved into several varieties of multi-user programmable virtual worlds. The most popular (at least for non-game uses) is MOO; it has been used for such widely varied purposes as system administration[Eva93], software process modeling[DHW98], collaborative OO design[HS95], collaborative astrophysics research [VBBCN96], telepresence microscopy[ZSE+96], and distance learning[KLS+98]. In fact MOO can be used to implement almost any multi-user application, from web servers to conferencing systems, and while the virtual world aspect of MOO is useful for a number of these applications, I believe that the reason for its success is its programming language, which enables and encourages an exploratory method of collaborative programming.

Open Problems

From a programming language perspective, however, the MOO language has some serious deficiencies. While the system is technically object-oriented, having objects that inherit fields and methods from other objects, the high overhead of object creation and the lack of automatic object garbage collection means that in practice most MOO programs are not truly object-oriented; most data structures are implemented using the built-in list type, while objects are used solely for virtual-world entities (or prototypical parent objects of these entities). The lack of first-class functions further limits the expressiveness of the language. From my experience with mud development, I believe that multiple inheritance and predicate dispatch (a generalization of multiple dispatch)[EKC98] would greatly enhance the ability for incremental development and code re-use in a collaborative language as well. MOO has fairly comprehensive facilities for the introspection and invocation aspects of a meta-object protocol[KP96], but very little support for intercession, i.e. allowing certain objects to override default behavior of the object system, such as method dispatch or field update; I believe this is another feature that is very important for exploratory programming. Of course, the Demeter group here at Northeastern has studied a number of approaches to encouraging evolution and re-use at the level of collections of cooperating objects (e.g. adaptive plug-and-play components[ML98]), and it would be fruitful to investigate these ideas in the context of a collaborative language.

From a multi-user system perspective, MOO has some limitations as well. Chief among these is the fact that it only supports cooperative multitasking; if a task uses more than a certain amount of time, or performs more than a certain number of operations, without yielding, then it is terminated with no recourse for cleanup. True preemptive multitasking would be much more powerful. Another problem with MOO as a multi-user system is the Unix-style security system; each field and method has an owner and a set of flags for read and write permission. A capability-based security system such as that discussed in[Ree96] would be much more flexible and clean. Other areas of investigation include distribution and a more robust approach to persistence-- MOO runs as a monolithic process which periodically pauses to fork and dump a snapshot of its heap.

Related Work

There have been a number of attempts to develop a collaborative programming language, both within and without the context of a virtual world system, with varying degrees of success. ColdC[Gil98] adds multiple inheritance, stronger encapsulation, lightweight objects, and a simple module system, as well as a more database-oriented persistent storage system. SchMUSE[BCLZ93] was a class-based distributed delegation object system built on top of MIT Scheme. Repo, used in the COTERIE toolkit[MF96] adds replicated objects to Obliq to support distributed interactive environments. CL-HTTP[Mal94] is a hypermedia server allowing users to write CGI scripts in Common Lisp. Matrix[Sar98] and POO[Str98] are projects attempting to add multi-user capabilities to Java and Python, respectively. Neverworld[Hor98] is a multi-user VRML world built on top of (and allowing users programmatic access to) Scheme48. Other collaborative language systems include MUQ, MudOS, COOLmud, FMPL, and Mu; these and other links (including all the references in this paper) can be found on my resources web page, .

Study Plan

For my Ph.D. thesis research I plan to investigate these systems in greater detail, with a focus on studying how language-level issues support collaborative exploratory programming. This may lead to the design and development of a new language, perhaps extending an existing collaborative language or else adding multi-user support to an existing exploratory language. I then intend to perform some experiments with users (perhaps based on the experiments in [Spr96]) to determine just how well this type of system enables exploratory collaborative programming, and how it compares both to single-user exploratory programming and collaboration with traditional tools. I also plan to investigate some of the theoretical issues of how best to formally model a collaborative language.

Fulfilling the course requirements

I have taken 6 classes since completing the Masters degree requirements:

For the project course (with Prof. Clinger), I implemented the basics of the BeCecil object system[CL97] in Scheme. I received an incomplete grade in the Machine Learning class, which I intend to clear this quarter by finishing my project on explanation-based learning. In the fall '98 quarter, I am taking two readings courses (COM 3800); one is a survey and feature comparison of collaborative language systems, with Prof. Lieberherr, and the other is a study of the formal semantics of MOO, with Prof. Wand.


My minor area of study is artificial intelligence, having taken three AI classes at NU. Of particular note is a paper I wrote for the Spring '98 quarter COM3411 class[Orl98]; this was an attempt to develop a natural language system for muds that did both parsing and generation using a unification grammar. Much of the work I did on JHCore (an object library for MOO) was related to natural language generation from template messages set by the user.

For the past two years I have been working as a part of the Demeter team on the implementation of the Demeter/Java system[HLM+98]. Prof. Lieberherr and I published a short description paper in the proceedings of ICSE 1997[LO97].


Michael R. Blair, Natalya Cohen, David M. LaMacchia, and Brian K. Zuzga.
MIT SchMUSE: Class-based remote delegation in a capricious distributed environment.
AI memo 1547, MIT, 1993.

Craig Chambers and Gary Leavens.
BeCecil, a core object-oriented language with block structure and multimethods: Semantics and typing.
In proceedings of the The Fourth International Workshop on Foundations of Object-Oriented Languages (FOOL 4), Paris, France, January 1997.

John C. Doppke, Dennis Heimbigner, and Alexander L. Wolf.
Software process modeling and execution within virtual environments.
ACM Transactions on Software Engineering and Methodology, 7(1):1-40, January 1998.

Michael D. Ernst, Craig Kaplan, and Craig Chambers.
Predicate dispatching: A unified theory of dispatch.
In ECOOP, pages 186-211, 1998.

Rémy Evard.
Collaborative networked communication: MUDs as systems tools.
In Proceedings of the Seventh Systems Administration Conference (LISA VII), pages 1-8, Monterey, CA, November 1993.

Brandon Gillespie.
The Cold project.
Web site, 1998. .

Geoff Hulten, Karl Lieberherr, Josh Marshall, Doug Orleans, and Binoy Samuel.
The Demeter/Java user manual.
In progress, 1998.

Ian Horswill.
Virtual environments and communities.
Web site, 1998. (middle of page).

Chris Hand and Mark Skipper.
A virtual environment for collaborative object-oriented design.
Technical Report TR95/5, Dept of Computer Science, De Montfort University, 1995.

Robert Kozma, Ruth Lang, Mark Schlager, Patricia Schank, Martin Fong, and Chris DiGiano.
Virtual places for collaborative distance learning.
Center for Technology in Learning, SRI International, 1998.

Gregor Kiczales and Andreas Paepcke.
Open implementations and metaobject protocols.
Xerox PARC Tutorial, 1996.

Karl Lieberherr and Doug Orleans.
Preventive program maintenance in Demeter/Java.
In Proceedings of International Conference on Software Engineering, pages 604-605, Boston, MA, 1997.

John C. Mallery.
A Common LISP hypermedia server.
In Proceedings of The First International Conference on The World-Wide Web, Geneva: CERN, May 1994.

Blair MacIntyre and Steven Feiner.
Language-level support for exploratory programming of distributed virtual environments.
In Proc. UIST '96, pages 83-95, Seattle, WA., November 1996.

Mira Mezini and Karl Lieberherr.
Adaptive plug-and-play components for evolutionary software development.
Technical Report NU-CCS-98-3, Northeastern University, College of Computer Science, April 1998.

Doug Orleans.
Natural language processing for multi-user virtual worlds.
COM 3411 class report, Spring quarter 1998.

Jonathan Rees.
A security kernel based on the lambda calculus.
AI memo 1564, MIT, March 1996.

Vijay Saraswat.
Matrix design notes.
Web site, 1998. .

Lindsey Spratt.
Seeing the Logic of Programming With Sets.
PhD thesis, Electrical Engineering and Computer Science Department of the University of Kansas, 1996.

Joe Strout.
POO (Pythonic MOO).
Web site, 1998. .

Dave Van Buren, Michael Brundage, Pavel Curtis, and David A. Nichols.
AstroVR, an on-line collaborative environment for research in astrophysics.
Project at CalTech, 1996.

N.J. Zaluzec, R. Stevens, R. Evard, T. Disz, R. Olson, and T. Kuhfuss.
Tele-presence microscopy & the ANL LabSpace (eLab) project.
Powergrid Journal, 1.01, 1996.

About this document ...

Plan of Study:
Exploratory Programming with Collaborative Programming Languages

This document was generated using the LaTeX2HTML translator Version 97.1 (release) (July 13th, 1997)

Copyright © 1993, 1994, 1995, 1996, 1997, Nikos Drakos, Computer Based Learning Unit, University of Leeds.

The command line arguments were:
latex2html -split 0 -dir html -no_navigation plan.

The translation was initiated by Doug Orleans on 10/16/1998

Doug Orleans