Logic Programming Based on Higher-Order Hereditary Harrop Formulas

Hereditary Harrop formulas are an extension to Horn clauses in which the body of clauses can contain implications and universal quantifiers. These formulas can further be extended by embedding them in a higher-order logic; that is, by permitting quantification over function symbol occurrences and some predicate symbol occurrences, and by replacing first-order terms with simply typed λ-terms. Our justification for considering this rich extension of Horn clause theory as a satisfactory logic programming language is provided by a proof-theoretic notion we call uniform proofs . This notion will be defined and motivated. This extended language can provide very natural and direct implementations of various kinds of abstraction mechanisms. For example, higher-order hereditary Harrop formulas (hohh) can be used to support aspects of modular programming, abstract data types, and higher-order programming. We have designed and built a logic programming system which implements hohh in much the same way Prolog implements first-order Horn clauses. This language and its interpreter, collectively called λProlog, will be described. We will present several example programs where λProlog provides a much more immediate and satisfactory implementation language than first-order Prologs. These examples are taken from theorem proving and program transformation. Finally, we will describe some aspects of our implementation of λProlog

Towards secure distributed computations

Nowadays, there are plenty of networks that work in a cooperative way and form what we know as grids of computers. These grids are serving a lot of purposes, and they are used with good results for intensive calculation, because the joined computing power aids in solving complex functions. To cope with these new requirements and facilities, programming languages had to evolve to new paradigms, including facilities to do distributed computing in a straightforward way. Functional programming is a paradigm that treats computation as the evaluation of mathematical functions. Functional programming languages implement the concepts introduced by this paradigm. Usually they are modeled using I» calculus, but other variants exist. In this line we have languages like ML, Haskell and (Pure)Lisp. This work has its focus on ML-like languages. As part of the evolution in grid computing, some functional programming languages were adapted to handle these new requirements. To be used in distributed contexts, the calculi had to be extended with new paradigms. Theoretic support for concurrent and distributed programming was conceived. For concurrent programming the I_ calculus was created, and this formalism was extended for mobility on the Ambient calculus. From these approaches, new functional languages were created. Examples of concurrent programming languages are Pict, occam-pi and Concurrent Haskell. In the case of distributed programming languages, we can mention Nomadic Pict, Alice and Acute. After the creation and utilization of such languages, an aspect remaining to be introduced is the security properties of these computations. The security properties of languages that execute on a single machine are difficult to achieve. Increased precautions must be take into account when dealing with lots of hosts and complex networks.Distributed programming languages must achieve, among other properties, correctness in its own abstractions: they must satisfy type-safety and abstraction safety. This work is concerned with correctness and safety in distributed languages, with focus on ML-like languages and the properties they have. To this aim, we have focused on a language called Acute. This language was born for doing research in distributed programming, and was created as a joint effort of the University of Cambridge and INRIA Rocquencourt. In Acute we have modern primitives for interaction between cooperating programs. Two primitives, marshal and unmarshal, have been introduced with this in mind. Acute has powerful properties: type and abstraction safety are guaranteed along the distributed system. But this only happens when there are no entities that can tamper with data transmitted between hosts. If this situation occurs, safety can be no longer guaranteed. The Acute language typechecks values at unmarshal time, to ensure its correctness. This can be made with values of concrete types, but if we have values of abstract types the situation os different: we may have only partial information to check, or the representation could be not available at all. So, how can values of abstract types be secured, in the context of a distributed programming language? We propose the use of a novel technique, called Proof Carrying Results. This technique is based on Neculaâ_Ts proof carrying code. Basically, the result of some computation comes equipped with a certificate, or witness, that can be used with abstract types.If the value comes with a witness that the computation was performed correctly, the caller can verify this witness and know that the value was generated in a good way. Throughout this thesis work, we will show how to add the PCR technique to a distributed programming language. The supporting infrastructure for the technique is introduced along with it. For checking the values and associated witnesses produced by some host, we use the COQ proof checker for a precise and reliable verification

Next generation software environments : principles, problems, and research directions

The past decade has seen a burgeoning of research and development in software environments. Conferences have been devoted to the topic of practical environments, journal papers produced, and commercial systems sold. Given all the activity, one might expect a great deal of consensus on issues, approaches, and techniques. This is not the case, however. Indeed, the term "environment" is still used in a variety of conflicting ways. Nevertheless substantial progress has been made and we are at least nearing consensus on many critical issues.The purpose of this paper is to characterize environments, describe several important principles that have emerged in the last decade or so, note current open problems, and describe some approaches to these problems, with particular emphasis on the activities of one large-scale research program, the Arcadia project. Consideration is also given to two related topics: empirical evaluation and technology transition. That is, how can environments and their constituents be evaluated, and how can new developments be moved effectively into the production sector

Acute: high-level programming language design for distributed computation

Existing languages provide good support for typeful programming of standalone programs. In a distributed system, however, there may be interaction between multiple instances of many distinct programs, sharing some (but not necessarily all) of their module structure, and with some instances rebuilt with new versions of certain modules as time goes on. In this paper we discuss programming language support for such systems, focussing on their typing and naming issues. We describe an experimental language, Acute, which extends an ML core to support distributed development, deployment, and execution, allowing type-safe interaction between separately-built programs. The main features are: (1) type-safe marshalling of arbitrary values; (2) type names that are generated (freshly and by hashing) to ensure that type equality tests suffice to protect the invariants of abstract types, across the entire distributed system; (3) expression-level names generated to ensure that name equality tests suffice for type-safety of associated values, e.g. values carried on named channels; (4) controlled dynamic rebinding of marshalled values to local resources; and (5) thunkification of threads and mutexes to support computation mobility. These features are a large part of what is needed for typeful distributed programming. They are a relatively lightweight extension of ML, should be efficiently implementable, and are expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store APIs. This disentangles the language runtime from communication intricacies. This paper highlights the main design choices in Acute. It is supported by a full language definition (of typing, compilation, and operational semantics), by a prototype implementation, and by example distribution libraries