Showing papers on "Functional logic programming published in 1985"

Programming expert systems in OPS5: an introduction to rule-based programming

Abstract: What do you do to start reading programming expert systems in ops5 an introduction to rule based programming the addison wesley series in artificial intelligence? Searching the book that you love to read first or find an interesting book that will make you want to read? Everybody has difference with their reason of reading a book. Actuary, reading habit must be from earlier. Many people may be love to read, but not a book. It's not fault. Someone will be bored to open the thick book with small words to read. In more, this is the real condition. So do happen probably with this programming expert systems in ops5 an introduction to rule based programming the addison wesley series in artificial intelligence.

Equational Logic as a Programming Language

Abstract: This book provides a comprehensive description of the theoretical foundations, design, and implementation of an innovative logic programming language in which computations are produced directly from equational definitions. Like LISP and Prolog, the equational programming language is based on the concept that a programmer should give a mathematical description of the result of a computation rather than a series of commands to direct a computation. Unlike LISP and Prolog, however, the equational programming language strictly follows the rules of equational logic, providing powerful programming techniques not available in conventional languages."Equational Logic as a Programming Language" covers the entire spectrum of theoretical and applied work involved in eight years of designing and implementing the equational logic programming language. Separate chapters cover the intuitive logical semantics of the language, the powerful programming techniques supported by it and their connections to procedural techniques such as coroutines, the methods used to produce a highly flexible implementation of the language with very little manpower, and the potential for implementation on parallel computers.Michael J. O'Donnell is Associate Professor of Computer Science at The Johns Hopkins University, on leave from Purdue University. "Equational Logic as a Programming Language" is included in the Foundations of Computing Series, edited by Michael Garey.

Introduction to Linear Goal Programming

Abstract: Introduction History and Applications Development of the LGP Model An Algorithm for Solution Algorithm Illustration Duality and Sensitivity Analysis Extensions

Domain-Specific Automatic Programming

Abstract: Domain knowledge is crucial to an automatic programming system and the interaction between domain knowledge and programming at the current time. The NIX project at Schlumberger-Doll Research has been investigating this issue in the context of two application domains related to oil well logging. Based on these experiments we have developed a framework for domain-specific automatic programming. Within the framework, programming is modeled in terms of two activities, formalization and implementation, each of which transforms descriptions of the program as it proceeds through intermediate states of development. The activities and transformations may be used to characterize the interaction of programming knowledge and domain knowledge in an automatic programming system.

Unification in Conditional Equational Theories

Abstract: A complete unification procedure for confluent conditional term rewriting systems is presented which is a generalization of the narrowing process described by Fay and Hullot Neither the finite termination property nor syntactical restrictions on conditions are needed The algorithm can be seen as a new functional logic programming technique, too The unification procedure has been built into the RAP system, a system supporting rapid prototyping for algebraic specifications

Language Constructs for Distributed Real-Time Programming

Abstract: For many distributed applications, it is not sufficient for programs to be logically correct. In addition, they must satisfy various timing constraints. This paper discusses primitives that support the construction of distributed real-time programs. Our discussion is focused in two areas: timing specification and communication. To allow the specifications of timing constraints, we introduce the language constructs for defining temporal scope and specifying message deadline. We also identify communication primitives needed for real-time programming. The issues underlying the selection of the primitives are explained, including handling of timing exceptions. The primitives will eventually be provided as part of a distributed programming system that will be used to construct distributed multi-sensory systems.

Concurrent Programming Using Actors: Exploiting Large-Scale Parallelism

Abstract: We argue that the ability to model shared objects with changing local states, dynamic reconfigurability, and inherent parallelism are desirable properties of any model of concurrency The {\it actor model} addresses these issues in a uniform framework This paper briefly describes the concurrent programming language {\it Act3} and the principles that have guided its development {\it Act3} advances the state of the art in programming languages by combining the advantages of object-oriented programming with those of functional programming We also discuss considerations relevant to large-scale parallelism in the context of {\it open systems}, and define an abstract model which establishes the equivalence of systems defined by actor programs

If Prolog is the Answer, What is the Question? or What it Takes to Support AI Programming Paradigms

Abstract: Knowledge programming, which makes use of the explicit representation and interpretation of knowledge to create intelligent programs, requires specialized languages and tools to help programmers. Prolog, an implementation of a logic programing language, provides some of these tools; it and other languages have been argued to be the "best" way to do such knowledge programming. This paper raises questions which suggest that any single paradigm of programming (e.g., logic programming or object-oriented programming) benefits by being integrated in a single environment with other paradigms of programming. Integration of these paradigms with each other, and within a flexible, user-friendly computing environment is also necessary. Such an environment must provide source level debugging and monitoring facilities, analysis and performance tuning tools, and an extended set of user communication programs.

Functional programing and the logical variable

Abstract: Logic programming offers a variety of computational effects which go beyond those customarily found in functional programming languages. Among these effects is the notion of the “logical variable.” i.e. a value determined by the intersection of constraints, rather than by direct binding. We argue that this concept is “separable” from logic programming, and can sensibly be incorporated into existing functional languages. Moreover, this extension appears to significantly widen the range of problems which can efficiently be addressed in function form, albeit at some loss of conceptual purity. In particular, a form of side-effects arises under this extension, since a function invocation can exert constraints on variables shared with other function invocations. Nevertheless, we demonstrate that determinacy can be retained, even under parallel execution. The graph reduction language FGL is used for this demonstration, by being extended to a language FGL+LV permitting formal parameter expressions, with variables occurring therein bound by unification. The determinacy argument is based on a novel dataflow-like rendering of unification. In addition the complete partial order employed in this proof is unusual in its explicit representation of demand, a necessity given the “benign” side-effects that arise. An implementation technique is suggested, suitable for reduction architectures.

Towards monolingual programming environments

Abstract: Most programming environments are much too complex. One way of simplifying them is to reduce the number of mode-dependent languages the user has to be familiar with. As a first step towards this end, the feasibility of unified command/programming/debugging languages, and the concepts on which such languages have to be based, are investigated. The unification process is accomplished in two phases. First, a unified command/programming framework is defined and, second, this framework is extended by adding an integrated debugging capability to it. Strict rules are laid down by which to judge language concepts presenting themselves as candidates for inclusion in the framework during each phase. On the basis of these rules many of the language design questions that have hitherto been resolved this way or that, depending on the taste of the designer, lose their vagueness and can be decided in an unambiguous manner.

Think Pad: A Graphical system for Program-ming bY Demonstration

Abstract: Specifying complex programs may become easier if the programming system allows the programmer to manipulate data structures graphically.

Logic Programming and Prolog: A Tutorial

Abstract: Logic programming offers significant advantages for the massively parallel computer systems of tomorrow. This tutorial examines the potential of Prolog to implement those advantages.

Constructive mathematics as a programming logic I: some principles of theory

Abstract: The design of a programming system is guided by certain beliefs, principles and practical constraints. These considerations are not always manifest from the rules defining the system. In this paper the author discusses some of the principles which have guided the design of the programming logics built at Cornell in the last decade. Most of the necessarily brief discussion concerns type theory with stress on the concepts of function space and quotient types.

A Tour Through Cedar

Abstract: This paperlintroduces the reader to many of the salient features of the Cedar programming environment, a state-of-the-art progrmming system that combines in a single integrated environment: high quality graphics, a sophisticated editor and document preparation facility, and a variety of tools for the programmer to use in the construction and debugging of his programs. The Cedar programming language [8] is a strongly typed, compiler-oriented language of the Pascal family. What is especially interesting about the Cedar project is that it is one of the few examples where an interactive, experimental programming environment has been built for this kind of language. In the past, such environments have been confined to dynamically typed languages like Lisp and Smalltalk.

The relation between logic programming and logic specification

Abstract: Formal logic is widely accepted as a program specification language in computing science. It is ideally suited to the representation of knowledge and the description of problems without regard to the choice of programming language. Its use as a specification language is compatible not only with conventional programming languages but also with programming languages based entirely on logic itself. In this paper I shall investigate the relation that holds when both programs and program specifications are expressed in formal logic. In many cases, when a specification completely defines the relations to be computed, there is no syntactic distinction between specification and program. Moreover the same mechanism that is used to execute logic programs, namely automated deduction, can also be used to execute logic specifications. Thus all relations defined by complete specifications are executable. The only difference between a complete specification and a program is one of efficiency. A program is more efficient than a specification.

Logic Programming as a Means of Representing Semantics in Design Languages

Abstract: Logic programming is discussed as a method for representing aspects of design language: descriptions of designs, domain knowledge, transformation rules (design grammar), and control mechanisms necessary to implement rules. The applicability of logic programming to the representation of semantics in design is also explored. Control at the semantic level provides a means of directing the automated generation of designs. Examples are drawn from a rule-based design system written in the logic programming language PROLOG.

From programming language design to computer construction

Abstract: From NELIAC (via ALGOL 60) to Euler and ALGOL W, to Pascal and Modula-2, and ultimately Lilith, Wirth's search for an appropriate formalism for systems programming yields intriguing insights and surprising results.