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




@TechReport{Backofen_Smolka:1992,
      AUTHOR = {Backofen, Rolf and Smolka, Gert},
      TITLE = {A Complete and Recursive Feature Theory},
      YEAR = {1992},
      NUMBER = {RR-92-30},
      ADDRESS = {Saarbrücken},
      TYPE = {Research Report},
      INSTITUTION = {DFKI},
      URL = {ftp://lt-ftp.dfki.uni-sb.de/pub/papers/local/RR-92-30.dvi.Z ftp://lt-ftp.dfki.uni-sb.de/pub/papers/local/RR-92-30.entry ftp://lt-ftp.dfki.uni-sb.de/pub/papers/local/RR-92-30.ps.Z},
      ANNOTE = {COLIURL : Backofen:1992:CRF.pdf Backofen:1992:CRF.ps Backofen:1992:CRF.dvi}
}

@InProceedings{Backofen_Smolka:1993,
      AUTHOR = {Backofen, Rolf and Smolka, Gert},
      TITLE = {A Complete and Recursive Feature Theory},
      YEAR = {1993},
      BOOKTITLE = {31st Annual Meeting of the Association for Computational Linguistics (ACL), June 22-26},
      PAGES = {193-200},
      ADDRESS = {Ohio State University Columbus, Ohio, USA},
      PUBLISHER = {Association for Computational Linguistics},
      URL = {ftp://lt-ftp.dfki.uni-sb.de/pub/papers/local/RR-92-30.dvi.Z ftp://lt-ftp.dfki.uni-sb.de/pub/papers/local/RR-92-30.entry ftp://lt-ftp.dfki.uni-sb.de/pub/papers/local/RR-92-30.ps.Z},
      ANNOTE = {COLIURL : Backofen:1993:CRF.pdf Backofen:1993:CRF.ps Backofen:1993:CRF.dvi}
}

@Article{Backofen_Smolka:1995,
      AUTHOR = {Backofen, Rolf and Smolka, Gert},
      TITLE = {A Complete and Recursive Feature Theory},
      YEAR = {1995},
      JOURNAL = {Theoretical Computer Science},
      VOLUME = {146},
      NUMBER = {1-2},
      PAGES = {243-268},
      URL = {ftp://lt-ftp.dfki.uni-sb.de/pub/papers/local/RR-92-30.dvi.Z ftp://lt-ftp.dfki.uni-sb.de/pub/papers/local/RR-92-30.entry ftp://lt-ftp.dfki.uni-sb.de/pub/papers/local/RR-92-30.ps.Z},
      ANNOTE = {COLIURL : Backofen:1995:CRF.pdf Backofen:1995:CRF.ps Backofen:1995:CRF.dvi}
}

@TechReport{Duchier_et_al:1998,
      AUTHOR = {Duchier, Denys and Kornstaedt, Leif and Schulte, Christian and Smolka, Gert},
      TITLE = {A Higher-Order Module Discipline with Separate Compilation, Dynamic Linking, and Pickling},
      YEAR = {1998},
      ADDRESS = {Saarbrücken},
      TYPE = {Technical Report},
      INSTITUTION = {Programming Systems Lab, DFKI and Universität des Saarlandes},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/modules-98.ps.gz},
      ABSTRACT = {We present a higher-order module discipline with separate compilation and concurrent dynamic linking. Based on first-order modules one can program security policies for systems that link modules from untrusted locations (e.g., Java). We introduce a pickling operation that writes persistent clones of volatile, possibly higher-order data structures on the file system. Our pickling operation respects lexical binding. Our module discipline is based on functors, which are annotated functions that are applied to modules and return modules. Pickled computed functors can be used interchangeably with compiled functors. In contrast to compiled functors, pickled computed functors can carry computed data structures with them, which has significant practical applications.},
      ANNOTE = {COLIURL : Duchier:1998:HOM.pdf Duchier:1998:HOM.ps}
}

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

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

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

@InProceedings{Müller_et_al:1997,
      AUTHOR = {Müller, Martin and Niehren, Joachim and Podelski, Andreas},
      TITLE = {Ordering Constraints over Feature Trees},
      YEAR = {1997},
      BOOKTITLE = {3rd International Conference on Principles and Practice of Constraint Programming (CP '97), October 29 - November 1},
      NUMBER = {1330},
      PAGES = {297-311},
      EDITOR = {Smolka, Gert},
      SERIES = {Lecture Notes in Computer Science},
      ADDRESS = {Schloss Hagenberg, Austria},
      PUBLISHER = {Springer},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/FTSub97.ps.gz},
      ABSTRACT = {Feature trees have been used to accommodate records in constraint programming and record like structures in computational linguistics. Feature trees model records, and feature constraints yield extensible and modular record descriptions. We introduce the constraint system FT$<$ of ordering constraints interpreted over feature trees. Under the view that feature trees represent symbolic information, the relation $<$ corresponds to the information ordering (carries less information than). We present a polynomial algorithm that decides the satisfiability of conjunctions of positive and negative information ordering constraints over feature trees. Our results include algorithms for the satisfiability problem and the entailment problem of FT$<$ in time $O(n^3)$. We also show that FT$<$ has the independence property and are thus able to handle negative conjuncts via entailment. Furthermore, we reduce the satisfiability problem of Dörre's weak-subsumption constraints to the satisfiability problem of FT$<$. This improves the complexity bound for solving weak subsumption constraints from $O(n^5)$ to $O(n^3)$.},
      ANNOTE = {COLIURL : Muller:1997:OCF.pdf Muller:1997:OCF.ps}
}

@TechReport{Müller_et_al:1997_1,
      AUTHOR = {Müller, Martin and Niehren, Joachim and Smolka, Gert},
      TITLE = {Typed Concurrent Programming with Logic Variables},
      YEAR = {1997},
      MONTH = {September},
      ADDRESS = {Saarbrücken},
      TYPE = {Technical Report},
      INSTITUTION = {Universität des Saarlandes, Programming Systems Lab},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/plain-report-97.ps.gz},
      ABSTRACT = {We present a concurrent higher-order programming language called Plain and a concomitant static type system. Plain is based on logic variables and computes with possibly partial data structures. The data structures of Plain are procedures, cells, and records. Plain's type system features record-based subtyping, bounded existential polymorphism, and access modalities distinguishing between reading and writing.},
      ANNOTE = {COLIURL : Muller:1997:TCP.pdf Muller:1997:TCP.ps}
}

@Article{Müller_Smolka:1996,
      AUTHOR = {Müller, Martin and Smolka, Gert},
      TITLE = {Oz: Nebenläufige Programmierung mit Constraints},
      YEAR = {1996},
      JOURNAL = {KI - Künstliche Intelligenz},
      VOLUME = {3},
      PAGES = {55-61},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/KI-LP96.ps.gz},
      ABSTRACT = {Dieser Artikel behandelt die Programmiersprache Oz und das ihr zugrundeliegende Programmiermodell. Oz ist eine nebenläufige Programmiersprache, die Constraintprogrammierung mit funktionaler und objektorientierter Programmierung verbindet. Oz ist als Nachfolger von Hochsprachen wie Lisp, Prolog und Smalltalk entworfen; diese Sprachen sind nur unzureichend für Anwendungen geeignet, die sowohl Problemlösungskomponenten enthalten, als auch Nebenläufigkeit und Reaktivität. Im Vergleich zu Prolog gibt Oz die Idee auf, dass Programme stets auch logische Spezifikationen sein müssen. Andererseits erlaubt Oz die flexible Programmierung von Inferenzmaschinen, deren Leistungsfähigkeit weit über das in Prolog Machbare hinausgeht. Damit steht insbesondere die Funktionalität von CLP-Sprachen wie CHIP bereit.},
      ANNOTE = {COLIURL : Muller:1996:ONP.pdf Muller:1996:ONP.ps}
}

@InProceedings{Podelski_Smolka:1995,
      AUTHOR = {Podelski, Andreas and Smolka, Gert},
      TITLE = {Situated Simplification},
      YEAR = {1995},
      BOOKTITLE = {1st Conference on Principles and Practice of Constraint Programming, September},
      NUMBER = {976},
      PAGES = {328-344},
      EDITOR = {Montanari, U.},
      SERIES = {Lecture Notes in Computer Science},
      ADDRESS = {Cassis, France},
      PUBLISHER = {Springer},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/SituSimpliTCS.ps.gz},
      ABSTRACT = {Testing satisfaction of guards is the essential operation of concurrent constraint programming (CCP) systems. We present and prove correct, for the first time, an incremental algorithm for the simultaneous tests of entailment and disentailment of rational tree constraints to be used in CCP systems with deep guards (e.g., AKL or Oz). The algorithm is presented as the simplification of the constraints which form the (possibly deep) guards and which are situated at different nodes (or, local computation spaces) in a tree (of arbitrary depth). In this algorithm, each variable may have multiple bindings (representing multiple constraints on the same variable in different nodes). These may be realized by re- and de-installation upon each newly resumed check of the guard in the corresponding node (as done, e.g., in AKL or Oz), or by using look-up tables (with entries indexed by the nodes). We give a simple fixed-point algorithm and use it for proving that the tests implemented by another, practical algorithm are correct and complete for entailment and disentailment. We formulate the results in this paper for rational tree constraints; they can be adapted to finite and feature trees.},
      ANNOTE = {COLIURL : Podelski:1995:SS.pdf Podelski:1995:SS.ps}
}

@Article{Podelski_Smolka:1997,
      AUTHOR = {Podelski, Andreas and Smolka, Gert},
      TITLE = {Situated Simplification},
      YEAR = {1997},
      JOURNAL = {Theoretical Computer Science},
      VOLUME = {173},
      PAGES = {209-233}
}

@InProceedings{Schulte:1997,
      AUTHOR = {Schulte, Christian},
      TITLE = {Programming Constraint Inference Engines},
      YEAR = {1997},
      BOOKTITLE = {3rd International Conference on Principles and Practice of Constraint Programming (CP '97), October 29 - November 1},
      NUMBER = {1330},
      PAGES = {519-533},
      EDITOR = {Smolka, Gert},
      SERIES = {Lecture Notes in Computer Science},
      ADDRESS = {Schloß Hagenberg, Austria},
      PUBLISHER = {Springer},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/Engines.ps.gz},
      ABSTRACT = {Existing constraint programming systems offer a fixed set of inference engines implementing search strategies such as single, all, and best solution search. This is unfortunate, since new engines cannot be integrated by the user. The paper presents first-class computation spaces as abstractions with which the user can program inference engines at a high level. Using computation spaces, the paper covers several inference engines ranging from standard search strategies to techniques new to constraint programming, including limited discrepancy search, visual search, and saturation. Saturation is an inference method for tautology-checking used in industrial practice. Computation spaces have shown their practicability in the constraint programming system Oz.},
      ANNOTE = {COLIURL : Schulte:1997:PCI.pdf Schulte:1997:PCI.ps}
}

@Article{Smolka:1996,
      AUTHOR = {Smolka, Gert},
      TITLE = {Problem Solving with Constraints and Programming},
      YEAR = {1996},
      JOURNAL = {ACM Computing Surveys},
      VOLUME = {28},
      NUMBER = {4},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/ACM_Surveys_96.ps.gz},
      ABSTRACT = {I sketch a general model of constraint-based problem solving that is not committed to a particular programming paradigm, show that Prolog in particular and logic programming in general do not provide a satisfactory framework for constraint programming, and outline how constraint programming is realized in Oz, a general-purpose language for symbolic processing.},
      ANNOTE = {COLIURL : Smolka:1996:PSC.pdf Smolka:1996:PSC.ps}
}

@InCollection{Smolka:1998,
      AUTHOR = {Smolka, Gert},
      TITLE = {Concurrent Constraint Programming Based on Functional Programming},
      YEAR = {1998},
      BOOKTITLE = {Programming Languages and Systems},
      VOLUME = {1381},
      PAGES = {1-11},
      EDITOR = {Hankin, Chris},
      SERIES = {Lecture Notes in Computer Science},
      ADDRESS = {Lisbon},
      PUBLISHER = {Springer},
      URL = {ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/Smolka-Oz-SML-98.ps.gz},
      ABSTRACT = {We show how the operational features of logic programming can be added as conservative extensions to a functional base language with call by value semantics. We will address both concurrent and constraint logic programming. As base language we will use a dynamically typed language that is obtained from SML by eliminating type declarations and static type checking. Our approach can be extended to cover all features of Oz. The experience with the development of Oz tells us that the outlined approach is the right base for the practical development of concurrent constraint programming languages. It avoids unnecessary duplication of concepts by reusing functional programming as core technology. Of course, it does not unify the partly incompatible theories behind functional and logic programming. They both contribute at a higher level of abstraction to the understanding of different aspects of the class of programming languages proposed here.},
      ANNOTE = {COLIURL : Smolka:1998:CCP.pdf Smolka:1998:CCP.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}
}

@InProceedings{Debusmann_et_al:2004,
      AUTHOR = {Debusmann, Ralph and Duchier, Denys and Koller, Alexander and Kuhlmann, Marco and Smolka, Gert and Thater, Stefan},
      TITLE = {A Relational Syntax-Semantics Interface Based on Dependency Grammar},
      YEAR = {2004},
      BOOKTITLE = {Proceedings of the 20th COLING},
      ADDRESS = {Geneva}
}