%
% 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: Michael_Mehl
%




@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}
}

@PhdThesis{Mehl:1999,
      AUTHOR = {Mehl, Michael},
      TITLE = {The Oz Virtual Machine - Records, Transients, and Deep Guards},
      YEAR = {1999},
      ADDRESS = {Saarbrücken},
      SCHOOL = {Universität des Saarlandes},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/mehl-thesis.ps.gz},
      ABSTRACT = {In this thesis we describe the design and implementation of a virtual machine LVM for the execution of Oz programs. Oz is a concurrent, dynamically typed, functional language with logic variables, futures, by-need synchronization, records, feature constraints, and deep guard conditionals. The LVM supports light-weight threads, first-class procedures, exception handling, transients as generalization of logic variables, futures, and constraint variables, records and open records, and multiple computation spaces to implement the deep guard conditional. We discuss the modular, open, and extensible design of the LVM. Techniques for the efficient implementation of the store on standard hardware are shown. The LVM subsumes well-known virtual machines for functional, logic, and imperative languages.},
      ANNOTE = {COLIURL : Mehl:1999:OVM.pdf Mehl:1999:OVM.ps}
}

@TechReport{Mehl_et_al:1998,
      AUTHOR = {Mehl, Michael and Schulte, Christian and Smolka, Gert},
      TITLE = {Futures and By-need Synchronization},
      YEAR = {1998},
      MONTH = {May},
      ADDRESS = {Saarbrücken},
      TYPE = {Draft},
      INSTITUTION = {DFKI and Universität des Saarlandes},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/oz-futures.ps.gz},
      ABSTRACT = {We propose a conservative extension of Oz that adds futures and by-need synchronization. Futures are read-only views of logic variables that make it possible to statically limit the scope in which a variable can be constrained. For instance, one can express with futures safe streams that cannot be assigned by their readers. By-need synchronization makes it possible to synchronize a thread on the event that a thread blocks on a future. It is used to express dynamic linking and lazy functions.}
}

@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}
}

@InProceedings{Van Roy_et_al:1996,
      AUTHOR = {Van Roy, Peter and Mehl, Michael and Scheidhauer, Ralf},
      TITLE = {Integrating Efficient Records into Concurrent Constraint Programming},
      YEAR = {1996},
      BOOKTITLE = {8th International Symposium on Programming Languages, Implementations, Logics, and Programs (PLILP '96), September 24-27},
      NUMBER = {1140},
      PAGES = {438-453},
      EDITOR = {Kuchen, Herbert and Swierstra, S. Doaitse},
      SERIES = {Lecture Notes in Computer Science},
      ADDRESS = {Aachen, Germany},
      PUBLISHER = {Springer},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/plilp96.ps.gz},
      ABSTRACT = {We show how to implement efficient records in constraint logic programming (CLP) and its generalization concurrent constraint programming (CCP). Records can be naturally integrated into CCP as a new constraint domain. The implementation provides the added expressive power of concurrency and fine-grained constraints over records, yet does not pay for this expressivity when it is not used. In addition to traditional record operations, our implementation allows to compute with partially-known records. This fine granularity is useful for natural-language and knowledge-representation applications. The paper describes the implementation of records in the DFKI Oz system. Oz is a higher-order CCP language with encapsulated search. We show that the efficiency of records in CCP is competitive with modern Prolog implementation technology and that our implementation provides improved performance for natural-language applications.},
      ANNOTE = {COLIURL : Roy:1996:IER.pdf Roy:1996:IER.ps}
}