Lucy(ID:1568/luc006)

Distributed constraint programming language. An actor subset of Janus
Related languages
Janus => Lucy   Subset
References:
  • Kahn, K. et al, "Actors as a Special Case of Concurrent Constraint Programming", pp57-66 view details Abstract: 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 (un-ordered 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. Extract: Introduction
    Introduction
    Actors are a minimal model of distributed computation. The model is lean and simple and adequately captures the essence of asynchronous message-passing systems. A good model for studying distributed systems need not, however, be a good basis for the design of programming languages intended to support the programming of large-scale distributed systems. We conjecture that the lack of wide-spread use of actor languages, despite twenty years of development, is due largely to the low-level nature of the actor model.
    We shall attempt to make the case that Janus as a superset of the Lucy actor language, enables the direct expression of many more common patterns of programming than actor languages while preserving the necessary properties for open-systems programming.
    A major technical shortcoming of the actor model is that it is not directly compositional. A configuration of actors, in general, is not itself an actor since it can respond to messages arriving at different ports. Introducing the concepts of receptionist and configuration enables compositionality while increasing the complexity of the actor model [l]. A major advantage of concurrent constraint programming is that the parallel composition of agents is itself an agent. Unlike actors, an agent can be receptive to communications on any number of ports.
    In the actor literature there is often talk of "mailboxes" or "mail addresses", though they are not part of the actor model. They are only implicitly part of an actor. This is because they are used in a standard manner which usually picks off and processes messages one by one. A major source of the expressiveness of Janus is that mailboxes are made explicit, agents may read from several of them, and separate read and write accesses may be communicated in messages. In order to mimic a simple Janus program in which agents use and communicate mailbox access rights, an actor program needs to build a relatively complex configuration of actors. The ability to read from multiple mailboxes also provides the basis for a simpler alternative mechanism for back communication than the continuations of actor computations. Multiple communication channels per agent and the communication of various kinds of access to communication channels are perhaps unusual programming language notions but are common in distributed operating systems (e.g. Mach). As such, Janus models current practice in distributed computation more directly than the lower-level modeling provided by actors.
          in [SIGPLAN] SIGPLAN Notices 25(10) October 1990 (OOPSLA/ECOOP '90) view details