Mozart announcement and comparison with Java platform

Mozart main site

Mozart 1.0 was released on Jan. 25, 1999.

Systems supported: Many Unix-based platforms, Windows 95/98/NT
Developers:

Summary

Mozart 1.0 is an extensive development platform for open fault-tolerant distributed applications, constraint programming applications, and logic programming applications. The platform implements the Oz language and is the fruit of a decade of research. The platform is released without charge with a very liberal license (X11-style) that allows both commercial and non-commercial use. Full source code is available. The platform includes a full-fledged interactive development environment with many libraries and tools. There is extensive documentation including tutorials covering all below mentioned application areas, a complete set of reference manuals, and many demos. The distribution, constraint, and logic programming abilities are the subject of ongoing research.

Mozart provides state-of-the-art support for distributed programming that separates the issues of application functionality, distribution structure, fault tolerance, and open computing. The implementation is fully network-transparent, i.e., an application obeys exactly the same semantics independent of its distribution structure, which is specified separately from the application functionality. The platform reflects distribution and fault tolerance in the language, providing abstractions that allow full control over these issues from within the language.

Mozart provides state-of-the-art support for constraint programming and logic programming. There are four constraint systems, namely rational trees (as in modern Prologs), finite domains, finite sets of integers, and record constraints. The platform is robust and able to handle big problems. Its performance is competitive with commercial solutions (including ILOG Solver, CHIP, SICStus Prolog, and Prolog IV), but it is much more expressive and flexible, providing first-class computation spaces, programmable search strategies, a GUI for the interactive exploration of search trees, parallel search engines that exploit networked computers, and a programming interface to add new, efficient constraint systems.

Distribution and constraint programming form a unique combination for emerging application areas. Intelligent multi-agent systems profit from having both aspects together. Furthermore, Mozart provides an easy-to-use parallel search engine for constraint programming and logic programming. This makes it easy for ordinary users to vastly increase the performance of compute-intensive applications, without having to rewrite them.

Applications

The Mozart consortium has developed significant applications with the platform. Here we give a brief overview; a more complete list is here. DFKI has developed a real-time bus scheduler, an intelligent manufacturing systems planner, a configuration tool, and an automatic music composition tool. DFKI uses Mozart as the base platform for its multi-agent research. UdS has developed a corpus browser. UCL has developed TransDraw, a state-of-the-art collaborative graphic editor that has high performance even over very slow networks. SICS has developed applications in train scheduling and radar configuration, and MIM (Mozart Instant Messager), an extended version of ICQ.

Development environment

The Mozart platform includes an interactive programming interface based on Emacs (both GNU Emacs and XEmacs are supported), an incremental compiler, development tools (including browser, interactive constraint visualizer, parser-generator, profiler, and debugger), an Internet-wide module system with dynamic linking, full Web support (applets, servlets, CGI), persistent data structures, an object-oriented graphics interface based on Tcl/Tk, powerful interoperability features including support for sockets and a C++ interface for dynamically-linked libraries, a distributed garbage collector, infinite precision arithmetic, and support for stand-alone applications. Furthermore, there are extensive libraries of constraints (including support for scheduling) and search engines including parallel engines. Performance is competitive with commercial Prolog and Lisp systems and is better than emulated Java.

Comparison with Java

It is interesting to compare Mozart with JDK 1.2. Mozart distinguishes itself from Java in the following ways:

Mozart provides true network transparency--in most cases not a single line of code has to be changed when changing the distribution structure of an application. In other words, the language semantics stays exactly the same independent of distribution structure. Furthermore, the distributed protocols used to implement transparency are network-aware: they provide a simple and predictable model for network communications. This provides a true separation of application functionality and network performance. Communications can be tuned independent of functionality.
Mozart provides a truly neutral network layer--it does not make any irrevocable decisions when there are temporary or permanent faults with processes or with the network. For example, there are no hard-wired time-outs in the network layer; if there is a sudden stop in network activity then the application has full control whether to continue waiting or to stop waiting.
Mozart provides a richer set of primitive operations for distributed programming: asynchronous many-to-many communication efficiently supported by the language (ports and data-flow variables), efficient distributed global naming with pure names (e.g., procedures, classes, and functors have unique global identities), synchronous and asynchronous failure detection in the language (detects crash failures of processes and network inactivity). See also a detailed producer-consumer example with Oz and Java code.
Mozart is fully extensible at run-time: one can for example upgrade the interface of a remote object interactively while the object is running and clients are communicating with it. This is a consequence of Mozart's dynamic typing and first-class messages.
Mozart has first-class module specifications (called ``functors''). They are referenced by value, not by string as Java classes. They specify exactly what resources they need, and they are sent across the network transparently when they are needed at a given site. A mobile agent abstraction can be built with functors.
Mozart provides sophisticated constraint programming and logic programming abilities and tools.
Creating and manipulating complex data structures is much more concise and efficient (by one order of magnitude) in Mozart than in JDK, and they are limited in size only by available memory. Oz shares this property with other symbolic languages (e.g., Lisp, Prolog, ML).
Oz is a multiparadigm language: it integrates many different programming ``styles'' or ``paradigms'' into a coherent execution model with a simple formal semantics. This permits a cleaner, more expressive programming style than in conventional languages. To a competent Oz programmer, the boundaries between these paradigms (e.g., logic, functional, object-oriented, constraint, concurrent, etc.) are artificial and irrelevant.
Oz is a data-flow language, i.e., computations are driven by availability of data. Combined with the efficient threads, this greatly simplifies concurrent programming (see following bullet).
Mozart provides a much more efficient implementation of concurrency--threads are two orders of magnitude more efficient. Furthermore, Mozart threads are preemptive; Java threads are not necessarily so. Concurrency in Mozart is a programming tool that can be used anywhere and everywhere it is desired. Together with the data-flow property, this makes concurrent programming in Mozart much simpler than in Java.
Mozart is released under a very liberal license that includes source code and permits both commercial and non-commercial use. We provide this license to encourage use and experimentation with the Mozart technology.