2,215 research outputs found
Objects in Oz
The programming language Oz integrates the paradigms of imperative, functional
and concurrent constraint programming in a computational framework of unprecedented
breadth, featuring stateful programming through cells, lexically scoped
higher-order programming, and explicit concurrency synchronized by logic variables.
Object-oriented programming is another paradigm that provides a set of concepts
useful in software practice. In this thesis we address the question how
object-oriented programming can be suitably supported in Oz. As a lexically
scoped higher-order language, Oz can express a wide range of object-oriented
concepts. We present a simple yet expressive object system, demonstrate its usability
and outline an efficient implementation. A central aspect of Oz is its support
for concurrent computation. We examine the impact of concurrency on the
design of an object system and explore the use of objects in concurrent programming.Die Programmiersprache Oz verbindet die Paradigmen der imperativen, funktionalen und nebenlĂ€ufigen Constraint-Programmierung in einem kohĂ€renten Berechnungsmodell. Oz unterstĂŒtzt zustandsbehaftete Programmierung, Programmierung höherer Ordnung mit lexikalischer Bindung und explizite NebenlĂ€ufigkeit, die mithilfe logischer Variablen synchroniziert werden kann. In der Softwarepraxis hat sich mit der objekt-orientierten Programmierung ein weiteres Programmierparadigma etabliert. In der vorliegenden Arbeit beschĂ€ftige ich mich mit der Frage, wie objekt-orientierte Programmierung in geeigneter Weise in Oz unterstĂŒtzt werden kann. Ich stelle ein einfaches und doch ausdrucksstarkes Objektsystem vor, belege seine Benutzbarkeit und umreiĂe seine effiziente Implementierung. Ein zentraler Aspekt der Programmiersprache Oz ist ihre UnterstĂŒtzung nebenlĂ€ufiger Berechnung. Infolgedessen nimmt die Untersuchung des Ein- flusses der NebenlĂ€ufigkeit auf das Design des Objektsystems einen besonderen Rang ein. Ich untersuche die Möglichkeiten, die das Objektsystem bietet, um nebenlĂ€ufige objekt-orientierte Programmiertechniken auszudrĂŒcken
Logic programming in the context of multiparadigm programming: the Oz experience
Oz is a multiparadigm language that supports logic programming as one of its
major paradigms. A multiparadigm language is designed to support different
programming paradigms (logic, functional, constraint, object-oriented,
sequential, concurrent, etc.) with equal ease. This article has two goals: to
give a tutorial of logic programming in Oz and to show how logic programming
fits naturally into the wider context of multiparadigm programming. Our
experience shows that there are two classes of problems, which we call
algorithmic and search problems, for which logic programming can help formulate
practical solutions. Algorithmic problems have known efficient algorithms.
Search problems do not have known efficient algorithms but can be solved with
search. The Oz support for logic programming targets these two problem classes
specifically, using the concepts needed for each. This is in contrast to the
Prolog approach, which targets both classes with one set of concepts, which
results in less than optimal support for each class. To explain the essential
difference between algorithmic and search programs, we define the Oz execution
model. This model subsumes both concurrent logic programming
(committed-choice-style) and search-based logic programming (Prolog-style).
Instead of Horn clause syntax, Oz has a simple, fully compositional,
higher-order syntax that accommodates the abilities of the language. We
conclude with lessons learned from this work, a brief history of Oz, and many
entry points into the Oz literature.Comment: 48 pages, to appear in the journal "Theory and Practice of Logic
Programming
The definition of kernel Oz
Oz is a concurrent language providing for functional, object-oriented, and constraint programming. This paper defines Kernel Oz, a semantically complete sublanguage of Oz. It was an important design requirement that Oz be definable by reduction to a lean kernel language. The definition of Kernel Oz introduces three essential abstractions: the Oz universe, the Oz calculus, and the actor model. The Oz universe is a first-order structure defining the values and constraints Oz computes with. The Oz calculus models computation in Oz as rewriting of a class of expressions modulo a structural congruence. The actor model is the informal computation model underlying Oz. It introduces notions like computation spaces, actors, blackboards, and threads
An overview of the ciao multiparadigm language and program development environment and its design philosophy
We describe some of the novel aspects and motivations behind
the design and implementation of the Ciao multiparadigm programming system. An important aspect of Ciao is that it provides the programmer with a large number of useful features from different programming paradigms and styles, and that the use of each of these features can be turned on and off at will for each program module. Thus, a given module may be using e.g. higher order functions and constraints, while another module may be using objects, predicates, and concurrency. Furthermore, the language is designed to be extensible in a simple and modular way. Another important aspect of Ciao is its programming environment, which provides a powerful preprocessor (with an associated assertion language) capable of statically finding non-trivial bugs, verifying that programs comply with specifications, and performing many types of program optimizations. Such optimizations produce code that is highly competitive with other dynamic languages or, when the highest levéis of optimization are used, even that of static languages, all while retaining the interactive development environment of a dynamic language. The environment also includes a powerful auto-documenter. The paper provides an informal overview of the language and program development environment. It aims at illustrating the design philosophy rather than at being exhaustive, which would be impossible in the format of a paper, pointing instead to the existing literature on the system
A simple approach to distributed objects in prolog
We present the design of a distributed object system for Prolog, based on adding remote execution and distribution capabilities to a previously existing object system. Remote execution brings RPC into a Prolog system, and its semantics is easy to express in terms of well-known Prolog builtins. The final distributed object design features state mobility and user-transparent network behavior. We sketch an implementation which provides distributed garbage collection and some degree of tolerance to network failures. We provide a preliminary study of the overhead of the communication mechanism for some test cases
The Oz programming model
The Oz Programming Model (OPM) is a concurrent programming model subsuming higher-order functional and object-oriented programming as facets of a general model. This is particularly interesting for concurrent object-oriented programming, for which no comprehensive formal model existed until now. The model can be extended so that it can express encapsulated problem solvers generalizing the problem solving capabilities of constraint logic programming. OPM has been developed together with a concomitant programming language Oz, which is designed for applications that require complex symbolic computations, organization into multiple agents, and soft real-time control. An efficient, robust, and interactive implementation of Oz is freely available
Encapsulated search and constraint programming in Oz
Oz is an attempt to create a high-level concurrent programming language providing the problem solving capabilities of logic programming (i.e., constraints and search). Its computation model can be seen as a rather radical extension of the concurrent constraint model providing for higher-order programming, deep guards, state, and encapsulated search. This paper focuses on the most recent extension, a higher-order combinator providing for encapsulated search. The search combinator spawns a local computation space and resolves remaining choices by returning the alternatives as first-class citizens. The search combinator allows to program different search strategies, including depth-first, indeterministic one solution, demand-driven multiple solution, all solutions, and best solution (branch and bound) search. The paper also discusses the semantics of integer and finite domain constraints in a deep guard computation model
An abstract machine for Oz
Oz is a concurrent constraint language providing for first-class procedures, concurrent objects, and encapsulated search. DFKI Oz is an interactive implementation of Oz competitive in performance with commercial Prolog and Lisp systems. This paper describes AMOZ, the abstract machine underlying DFKI Oz. AMOZ implements rational tree constraints, first-class procedures, local computation spaces for deep guards, and preemptive and fair threads
A calculus for higher-order concurrent constraint programming with deep guards
We present a calculus providing an abstract operational semantics forhigher-order concurrent constraint programming. The calculus isparameterized with a first-order constraint system and provides first-class abstraction, guarded disjunction, committed-choice, deepguards, dynamic creation of unique names, and constraint communication.The calculus comes with a declarative sublanguage for which computation amounts to equivalence transformation of formulas. The declarative sublanguage can express negation. Abstractions are referred to by names, which are first-class values. This way we obtain a smooth and straight forward combination of first-order constraints with higher-order programming. Constraint communication is asynchronous and exploits the presence of logic variables. It provides a notion of state that is fully compatible with constraints and concurrency. The calculus serves as the semantic basis of Oz, a programming language and system under development at DFKI
Multi-agent planning using an abductive : event calculus
Temporal reasoning within distributed Artificial Intelligence Systems is faced with the problem of concurrent streams of action. Well known, logic-based systems using the SITUATION CALCULUS solve the frame problem in a purely linear manner. Recent research, however, has revealed that the EVENT CALCULUS under the abduction principle is capable of nonlinear planning. In this report, we present a planning service module which incorporates this approach into a constraint logic framework and even allows a notion of strong nonlinearity. The work includes the axiomatisation of appropriate versions of the EVENT CALCULUS, the development of a suitably sound and complete proof procedure that supports abduction and the implementation of both of these layers on the constraint platform OZ. We demonstrate prototypically how this module, EVE, can be integrated into an existing multi-agent architecture and evaluate the behaviour of such agents within an application domain, the loading dock scenario
- âŠ