saraswat@roo.uucp (Vijay Saraswat) (07/26/90)
The following technical reports are available from: Systems Sciences Laboratory, Xerox PARC 3333 Coyote Hill Road, Palo Alto Ca 94304 ------------------------ Janus: A step towards distributed constraint programming Vijay A. Saraswat and Ken Kahn, Xerox PARC Jacob Levy, Technion, Haifa (Extended Abstract) (saraswat@parc.xerox.com) (To appear in Proceedings of the 1990 North American Conference on Logic Programming, ed. Debray and Hermenegildo, MIT Press.) We propose a new language, Janus, to address shortcomings of concurrent logic programming languages for distributed programming. Unlike parallel computing, distributed computing must facilitate interactions between very large numbers of diverse computations without central coordination or trust. Janus is a member of the dc family of distributed constraint programming languages, a subset of the cc family (of concurrent constraint programming languages). dc languages are ``failure-free'', which is essential if they are to be used for distributed computing. The general cc framework provides a conceptual framework which aids in providing a simple yet formal semantics for Janus, as well as understanding its relationship with other languages. Janus, along with other concurrent logic programming languages, is based on asynchronous, buffered message passing and provides, in a simple and clean way, unbounded, recursive invocation of agents, indeterministic selection and ``private'' communication hidden from the ``environment''. Its main novelty is its simple yet powerful communication and synchronization mechanism based on single-message, point-to-point, directional channels in which reception or transmission rights for channels can themselves be passed in messages. Janus provides operations upon arrays which enable the expression and efficient execution of conventional programming idioms. It also provides bags of unordered elements which are used for many--to--one communication without the need for merge networks. The language design enables data deallocation and reuse as soon as the data becomes garbage. Logical errors that arise during computation can be trapped and handled by user code. Communication protocols between Janus implementations and other computations (possibly other nodes executing Janus) are much simpler than those for other concurrent logic programming languages which need to support distributed unification and garbage collection, thus enhancing inter-operability. ----------------------------- Actors as a Special Case of Concurrent Constraint Programming Kenneth M. Kahn and Vijay A. Saraswat Xerox Palo Alto Research Center 3333 Coyote Hill Road, Palo Alto, CA 94304, USA (415) 494-4390; 494-4334 (FAX) Kahn@PARC.Xerox.com (To appear in 1990 ECOOP/OOPSLA Conference Proceedings.) Saraswat recently introduced the framework of concurrent constraint programming. The essence of the framework is that computations consist of concurrent agents interacting by communicating constraints. Several concurrent constraint programming languages have been defined. They differ in the kinds of constraints that can be used as well as the kinds of operations on constraints which are available. In this paper we introduce a very simple concurrent constraint language we call Lucy, designed to closely mimic the actor model of computation. Agents can communicate only by the posting of constraints upon bags (unordered collections possibly with duplicate elements). This very impoverished concurrent constraint language is a syntactic subset of Janus, a concurrent constraint language which closely resembles concurrent logic programming languages such as Guarded Horn Clauses, Strand, Parlog and Flat Concurrent Prolog. By identifying the subset of Janus which is an actor language, we elucidate the relationship between actors and concurrent logic programming (and its generalization as concurrent constraint programming). Lucy is best not thought of as a unification of logic and constraint programming with actor and object-oriented programming, but as the *missing link* between these programming language genera.