%
% GENERATED FROM https://www.coli.uni-saarland.de
%    by   : anonymous
%    IP   : coli2006.lst.uni-saarland.de
%    at   : Mon, 05 Feb 2024 15:43:21 +0100 GMT
%    
% Selection : Author: Seif_Haridi
%




@Article{Haridi_et_al:1999,
      AUTHOR = {Haridi, Seif and Van Roy, Peter and Brand, Per and Mehl, Michael and Scheidhauer, Ralf and Smolka, Gert},
      TITLE = {Efficient Logic Variables for Distributed Computing},
      YEAR = {1999},
      JOURNAL = {ACM Transactions on Programming Languages and Systems},
      VOLUME = {21},
      NUMBER = {3},
      PAGES = {569-626},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/TOPLAS99.ps.gz},
      ABSTRACT = {We define a practical algorithm for distributed rational tree unification and prove its correctness in both the off-line and on-line cases. We derive the distributed algorithm from a centralized one, showing clearly the trade-offs between local and distributed execution. The algorithm is used to realize logic variables in the Mozart Programming System, which implements the Oz language (see http://www.mozart-oz.org/). Oz appears to the programmer as a concurrent object-oriented language with dataflow synchronization. Logic variables implement the dataflow behavior. We show that logic variables can easily be added to the more restricted models of Java and ML, thus providing an alternative way to do concurrent programming in these languages. We present common distributed programming idioms in a network-transparent way using logic variables. We show that in common cases the algorithm maintains the same message latency as explicit message passing. In addition, it is able to handle uncommon cases that arise from the properties of latency tolerance and third-party independence. This is evidence that using logic variables in distributed computing is beneficial at both the system and language levels. At the system level, they improve latency tolerance and third-party independence. At the language level, they help make network-transparent distribution practical.},
      ANNOTE = {COLIURL : Haridi:1999:ELV.pdf Haridi:1999:ELV.ps}
}

@Article{Haridi_et_al:1998,
      AUTHOR = {Haridi, Seif and Van Roy, Peter and Brand, Per and Schulte, Christian},
      TITLE = {Programming Languages for Distributed Applications},
      YEAR = {1998},
      JOURNAL = {New Generation Computing},
      VOLUME = {16},
      NUMBER = {3},
      PAGES = {223-261},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/ngc98.ps.gz},
      ABSTRACT = {Much progress has been made in distributed computing in the areas of distribution structure, open computing, fault tolerance, and security. Yet, writing distributed applications remains difficult because the programmer has to manage models of these areas explicitly. A major challenge is to integrate the four models into a coherent development platform. Such a platform should make it possible to cleanly separate an application's functionality from the other four concerns. Concurrent constraint programming, an evolution of concurrent logic programming, has both the expressiveness and the formal foundation needed to attempt this integration. As a first step, we have designed and built a platform that separates an application's functionality from its distribution structure. We have prototyped several collaborative tools with this platform, including a shared graphic editor whose design is presented in detail. The platform efficiently implements Distributed Oz, which extends the Oz language with constructs to express the distribution structure and with basic primitives for open computing, failure detection and handling, and resource control. Oz appears to the programmer as a concurrent object-oriented language with dataflow synchronization. Oz is based on a higher-order, state-aware, concurrent constraint computation model.},
      ANNOTE = {COLIURL : Haridi:1998:PLD.pdf Haridi:1998:PLD.ps}
}

@InProceedings{Haridi_et_al:1997,
      AUTHOR = {Haridi, Seif and Van Roy, Peter and Smolka, Gert},
      TITLE = {An Overview of the Design of Distributed Oz},
      YEAR = {1997},
      BOOKTITLE = {2nd International Symposium on Parallel Symbolic Computation (PASCO '97), July 20-22},
      PAGES = {176-187},
      ADDRESS = {Maui, Hawaii, USA},
      PUBLISHER = {ACM Press},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/PASCO97.ps.gz},
      ABSTRACT = {We present a design for a distributed programming system, Distributed Oz, that abstracts away the network. This means that all network operations are invoked implicitly by the system as an incidental result of using particular language constructs. However, since network operations are expensive, the programmer must retain control over network communication patterns. This control is provided through the language constructs. While retaining their centralized semantics, they are extended with a distributed semantics. Distributed Oz is an extension of Oz, a concurrent state-aware language with first-class procedures. Distributed Oz extends Oz with just two concepts: mobility control and asynchronous ordered communication. Mobility control provides for truly mobile objects in a simple and clean way. Asynchronous ordered communication allows to conveniently build servers. These two concepts give the programmer a control over network communications that is both simple and predictable. We give scenarios to show how common distributed programming tasks can be implemented efficiently. There are two reasons for the simplicity of Distributed Oz. First, Oz has a simple formal semantics. Second, the distributed extension is built using network protocols that are natural extensions to the centralized language operations. We discuss the operational semantics of Oz and Distributed Oz and the architecture of the distributed implementation. We give an overview of the basic network protocols for communication and mobility.},
      ANNOTE = {COLIURL : Haridi:1997:ODD.pdf Haridi:1997:ODD.ps}
}

@Article{Van Roy_et_al:1997,
      AUTHOR = {Van Roy, Peter and Haridi, Seif and Brand, Per and Smolka, Gert and Mehl, Michael and Scheidhauer, Ralf},
      TITLE = {Mobile Objects in Distributed Oz},
      YEAR = {1997},
      JOURNAL = {ACM Transactions on Programming Languages and Systems},
      VOLUME = {19},
      NUMBER = {5},
      PAGES = {804-851},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/TOPLAS97.ps.gz},
      ABSTRACT = {Some of the most difficult questions to answer when designing a distributed application are related to mobility: what information to transfer between sites and when and how to transfer it. Network-transparent distribution, the property that a program's behavior is independent of how it is partitioned among sites, does not directly address these questions. Therefore we propose to extend all language entities with a network behavior that enables efficient distributed programming by giving the programmer a simple and predictable control over network communication patterns. In particular, we show how to give objects an arbitrary mobility behavior that is independent of the object's definition. In this way, the syntax and semantics of objects are the same regardless of whether they are used as stationary servers, mobile agents, or simply as caches. These ideas have been implemented in Distributed Oz, a concurrent object-oriented language that is state aware and has data flow synchronization. We prove that the implementation of objects in Distributed Oz is network transparent. To satisfy the predictability condition, the implementation avoids forwarding chains through intermediate sites. The implementation is an extension to the publicly available DFKI Oz 2.0 system.},
      ANNOTE = {COLIURL : Roy:1997:MOD.pdf Roy:1997:MOD.ps}
}