Principles Of Programming Languages Research Articles

Set Constraints and Logic Programming

Set constraints are inclusion relations between expressions denoting sets of ground terms over a ranked alphabet. They are the main ingredient in set-based program analysis. In this paper we describe a constraint logic programming language clp ( sc ) over set constraints in the style of J. Jaffar and J.-L. Lassez (1987, “Proc. Symp. Principles of Programming Languages 1987,” pp. 111–119). The language subsumes ordinary logic programs over an Herbrand domain. We give an efficient unification algorithm and operational, declarative, and fixpoint semantics. We show how the language can be applied in set-based program analysis by deriving explicitly the monadic approximation of the collecting semantics of N. Heintze and J. Jaffar (1992, “Set Based Program Analysis”; 1990, “Proc. 17th Symp. Principles of Programming Languages,” pp. 197–209).

A taxonomy for simulation modeling based on programming language principles

Although many diverse areas employ simulation models, no agreed-upon taxonomy has been developed to categorize and structure simulation models for all science and engineering disciplines. The discipline of simulation is often splintered due to this lack of structure, with ad hoc model classes such as ‘discrete event,’ ‘continuous’ and ‘combined.’ These classes most often reflect the method of execution used on a model rather than the design structure of the model. We present a uniform model design taxonomy whose categories are inspired from categories in programming language principles within the field of computer science. The taxonomy includes a set of primitive model types (conceptual, declarative, functional, constraint, spatial) and a way of integrating primitive model types together (multimodeling). These model types are discussed using a single application: a robot server for an assembly line. We have found this taxonomy enables simulators to more easily define and categorize their models as well as to understand how model types from seemingly disparate application areas are interrelated.

The call-by-need lambda calculus

Plotkin (1975) showed that the lambda calculus is a good model of the evaluation process for call-by-name functional programs. Reducing programs to constants or lambda abstractions according to the leftmost-outermost strategy exactly mirrors execution on an abstract machine like Landin's SECD machine. The machine-based evaluator returns a constant or the token closure if and only if the standard reduction sequence starting at the same program will end in the same constant or in some lambda abstraction. However, the calculus does not capture the sharing of the evaluation of arguments that lazy implementations use to speed up the execution. More precisely, a lazy implementation evaluates procedure arguments only when needed and then only once. All other references to the formal procedure parameter re-use the value of the first argument evaluation. The mismatch between the operational semantics of the lambda calculus and the actual behavior of the prototypical implementation is a major obstacle for compiler writers. Unlike implementors of the leftmost-outermost strategy or of a call-by-value language, implementors of lazy systems cannot easily explain the behavior of their evaluator in terms of source level syntax. Hence, they often cannot explain why a certain syntactic transformation ‘works’ and why another doesn't. In this paper we develop an equational characterization of the most popular lazy implementation technique – traditionally called ‘call-by-need’ – and prove it correct with respect to the original lambda calculus. The theory is a strictly smaller theory than Plotkin's call-by-name lambda calculus. Immediate applications of the theory concern the correctness proofs of a number of implementation strategies, e.g. the call-by-need continuation passing transformation and the realization of sharing via assignments. Some of this material first appeared in a paper presented at the 1995 ACM Conference on the Principles of Programming Languages. The paper was a joint effort with Maraist, Odersky and Wadler, who had independently developed a different equational characterization of call-by-need. We contrast our work with that of Maraist et al. in the body of this paper where appropriate.

Region-Based Memory Management

This paper describes a memory management discipline for programs that perform dynamic memory allocation and de-allocation. At runtime, all values are put intoregions. The store consists of a stack of regions. All points of region allocation and de-allocation are inferred automatically, using a type and effect based program analysis. The scheme does not assume the presence of a garbage collector. The scheme was first presented in 1994 (M. Tofte and J.-P. Talpin,in“Proceedings of the 21st ACM SIGPLAN–SIGACT Symposium on Principles of Programming Languages,” pp. 188–201); subsequently, it has been tested in The ML Kit with Regions, a region-based, garbage-collection free implementation of the Standard ML Core language, which includes recursive datatypes, higher-order functions and updatable references L. Birkedal, M. Tofte, and M. Vejlstrup, (1996),in“Proceedings of the 23 rd ACM SIGPLAN–SIGACT Symposium on Principles of Programming Languages,” pp. 171–183. This paper defines a region-based dynamic semantics for a skeletal programming language extracted from Standard ML. We present the inference system which specifies where regions can be allocated and de-allocated and a detailed proof that the system is sound with respect to a standard semantics. We conclude by giving some advice on how to write programs that run well on a stack of regions, based on practical experience with the ML Kit.

Type-Directed Partial Evaluation

<p>We present a strikingly simple partial evaluator, that is type-directed and reifies a compiled program into the text of a residual, specialized program. Our partial evaluator is concise (a few lines) and it handles the flagship examples of offline monovariant partial evaluation. Its source programs are constrained in two ways: they must be closed and monomorphically typable. Thus dynamic free variables need to be factored out in a ``dynamic initial environment´´. Type-directed partial evaluation uses no symbolic evaluation for specialization, and naturally processes static computational effects.</p><p>Our partial evaluator is the part of an offline partial evaluator that residualizes static values in dynamic contexts. Its restriction to the simply typed lambda-calculus coincides with Berger and Schwichtenberg's ``inverse of the evaluation functional´´ (LICS'91), which is an instance of normalization in a logical setting. As such, type-directed partial evaluation essentially achieves lambda-calculus normalization. We extend it to produce specialized programs that are recursive and that use disjoint sums and computational effects. We also analyze its limitations: foremost, it does not handle inductive types.</p><p>This paper therefore bridges partial evaluation and lambda-calculus normalization through higher-order abstract syntax, and touches upon parametricity, proof theory, and type theory (including subtyping and coercions), compiler optimization, and run-time code generation (including decompilation). It also offers a simple solution to denotational semantics-based compilation and compiler generation.</p><p>Proceedings of POPL96, the 1996 ACM Symposium on Principles of Programming Languages (to appear).</p>

Structured operational semantics and bisimulation as a congruence

In this paper we are interested in general properties of classes of transition system specifications in Plotkin style. The discussion takes place in a setting of labelled transition systems. The states of the transition systems are terms generated by a single sorted signature and the transitions between states are defined by conditional rules over the syntax. It is argued that in this setting it is natural to require that strong bisimulation equivalence be a congruence on the states of the transition systems. A general format, called the tyft/tyxt format, is presented for the rules in a transition system specification, such that bisimulation is always a congruence when all the rules fit this format. With a series of examples it is demonstrated that the tyft/tyxt format cannot be generalized in any obvious way. Another series of examples illustrates the usefulness of our congruence theorem. Briefly we touch upon the issue of modularity of transition system specifications. It is argued that certain pathological tyft/tyxt rules (the ones which are not pure) can be disqualified because they behave badly with respect to modularization. Next we address the issue of full abstraction. We characterize the completed trace congruence induced by the operators in pure tyft/tyxt format as 2-nested simulation equivalence. The pure tyft/tyxt format includes the format given by de Simone (Theoret. Comput. Sci.37, 245–267 (1985)) but is incomparable to the GSOS format of Bloom, Istrail, and Meyer (in“Conference Record of the 15th Annual Symposium on Principles of Programming Languages, San Diego, California, 1988,” pp. 229–239). However, it turns out that 2-nested simulation equivalence strictly refines the completed trace congruence induced by the GSOS format.

Partial Types and Intervals

The main idea of this paper is to develop an inference system to assign partial types to terms of the untyped lambda calculus. A term can either be necessarily or possibly of a certain type; these notions of necessity and possibility are incorporated into the type inference system as modalities. A subclass of types are the total types, for which necessity and possibility are equivalent. In the semantics the meaning of a total type is a set of values in the domain, the meaning of a type being, in general, an interval (a set of sets of values). This is a generalization of Cartwright’s semantics [Conference Record of the 12th Annual ACM Symposium on Principles of Programming Languages, Association for Computing Machinery, New York, 1984, pp. 22–36]. The main results are the soundness and completeness of the type inference system with respect to interval semantics.

Strictness analysis and denotational abstract interpretation

A theory of abstract interpretation ( P. Cousot and R. Cousot, in “Conf. Record, 4th ACM Symposium on Principles of Programming Languages,” 1977 ) is developed for a typed λ-calculus. The typed λ-calculus may be viewed as the “static” part of a two-level denotational metalanguage for which abstract interpretation was developed by Nielson, 1984 , Nielson, 1986a , Nielson, 1986b ). The present development relaxes a condition imposed there and this sufices to make the framework applicable to strictness analysis for the λ-calculus. This shows the possibility of a general theory for the analysis of functional programs and it gives more insight into the relative precision of the various analyses. In particular it is shown that a collecting (static; P. Cousot and R. Cousot, in “Conf. Record, 6th ACM Symposium on Principles of Programming Languages,” 1979 ) semantics exists, thus answering a problem left open by G. L. Burn, C. L. Hankin and S. Abramsky ( Sci. Comput. Programming 7 (1986) , 249–278).

A refinement of strong sequentiality for term rewriting with constructors

The notion of call-by-need evaluation has turned out to be very fruitful when applied to dialects of the λ-calculus (Henderson and Morris, 1976 , in “Proc. 3rd ACM Symp. on the Principles of Programming Languages, Atlanta; Kahn and Mac Queen, 1977 , in “IFIP 77”, North-Holland, Amsterdam; Turner, 1979 , Software Practice and Experience, Vol. 9; Vuillemin, 1974 , J. Comput. Systems Sci. , 9 , 332–354; Wadsworth, 1971 , Ph.D. dissertation, Oxford University, England). The analogous idea of sequentiality for term rewriting systems described by firstorder equations has been considered by , in “Proc. 5th ACM Symp. on the Principles of Programming Languages, San Antonio”, 1984, in “Proc. 11th ACM Symp. on the Principles of Programming Languages, Salt Lake City) and Huet-Levy (1979, Technical Report No. 359, INRIA, Le Chesney, France), of which the latter is generally considered to be the most complete theoretical treatment of the subject to date. Huet-Levy (1979) defined the notion of strong sequentiality to describe the class of linear term rewriting systems for which call-by-need computation is practical. This paper introduces an improved version of strong sequentiality called left sequentiality. Unlike strong sequentiality, left sequentiality is based on possible rather than arbitrary (and often impossible) sequences of reductions. We show that left sequentiality is more general than strong sequentiality when applied to individual terms, but is equivalent to the latter when cosidered as a property of admissible sets of left-hand sides for systems of equations. Huet-Levy (1979) showed that there are safe redex selection algorithms, i.e., algorithms deriving normal forms whenever possible, for systems based on strongly sequential sets of left-hand sides. We show that there is no algorithm which is safe for all systems based on a set of left-hand sides if that set is not left sequential. In other words, left sequentiality is not only sufficient, it is also necessary for safe computation based on the analysis of left-hand sides alone.

A course in programming languages for computer science majors

This paper presents my first experience in teaching third year computer science majors a course entitled, "Principles of Programming Languages" at the Chinese University of Hong Kong. The course has been aimed at teaching the students to analyze and to evaluate a high-level programming language; it also enables the students to gain knowledge in a wide spectrum of current programming languages. In this paper, the preparation, the teaching materials, the organization, and the actual running of the course are described.

A zero-one law for logic with a fixed-point operator

The logic obtained by adding the least-fixed-point operator to first-order logic was proposed as a query language by Aho and Ullman (in “Proc. 6th ACM Sympos. on Principles of Programming Languages,” 1979, pp. 110–120) and has been studied, particularly in connection with finite models, by numerous authors. We extend to this logic, and to the logic containing the more powerful iterative-fixed-point operator, the zero-one law proved for first-order logic in (Glebskii, Kogan, Liogonki, and Talanov (1969), Kibernetika 2, 31–42; Fagin (1976), J. Symbolic Logic 41, 50–58). For any sentence φ of the extend logic, the proportion of models of φ among all structures with universe {1,2,…, n} approaches 0 or 1 as n tends to infinity. We also show that the problem of deciding, for any φ, whether this proportion approaches 1 is complete for exponential time, if we consider only φ's with a fixed finite vocabulary (or vocabularies of bounded arity) and complete for double-exponential time if φ is unrestricted. In addition, we establish some related results.

Principles of programming languages: Design, evaluation, and implementation

Principles of programming languages: Design, evaluation, and implementation

Decision procedures and expressiveness in the temporal logic of branching time

We consider the computation tree logic (CTL) proposed in ( Sci. Comput. Programming 2 (1982), 241–260) which extends the unified branching time logic (UB) of (“Proc. Ann. ACM Sympos. Principles of Programming Languages, 1981,” pp. 164–176) by adding an until operator. It is established that CTL has the small model property by showing that any satisfiable CTL formulae is satisfiable in a small finite model obtained from the small “pseudomodel” resulting from the Fischer-Ladner quotient construction. Then an exponential time algorithm is given for deciding satisfiability in CTL, and the axiomatization of UB given in ibid. is extended to a complete axiomatization for CTL. Finally, the relative expressive power of a family of temporal logics obtained by extending or restricting the syntax of UB and CTL is studied.

Loops in combinator-based compilers

In M. Wand (1982, in “Conf. Rec. 9th ACM Sympos. on Principles of Programming Languages,” pp. 234–241, Assoc. Comput. Mach., New York) a paradigm for compilation based on combinators was introduced. A program from a source language is translated (via a semantic definition) to trees of combinators; the tree is simplified (via associative and distributive laws) to a linear, assembly-language-like format; the “compiler writer's virtual machine” operates by simulating a reduction sequence of the simplified tree. The correctness of the transformations follows from general results about the λ -calculus. The code produced by such a generator is always tree-like. In this paper, the method is extended to produce target code with explicit loops. This is done by re-introducing variables into the terms of the target language is a restricted way, along with a structured binding operator. General conditions under which these transformations hold are also considered.

Proofs by induction in equational theories with constructors

We show how to prove (and disprove) theorems in the initial algebra of an equational variety by a simple extension of the Knuth-Bendix completion algorithm. This allows us to prove by purely equational reasoning theorems whose proof usually requires induction. We show applications of this method to proofs of programs computing over data structures, and to proofs of algebraic-summation identities. This work extends and simplifies recent results of Musser, “Proc., 7th Annual ACM Symposium on Principles of Programming Languages,” Las Vegas, January 1980, pp. 154–162, and Goguen, “Proc., 5th Conf. on Automated Deduction,” Les Arcs, July 1980, pp. 356–373.

Special Editor's Note

Three ACM symposia on Principles of Programming Languages, jointly sponsored by SIGACT and SIGPLAN, have now been held. The first symposium was in October 1973, the second in January 1975, and the ...

Special Editor's Note

Three ACM symposia on Principles of Programming Languages, jointly sponsored by SIGACT and SIGPLAN, have now been held. The first symposium was in October 1973, the second in January 1975, and the third the following year. It is now planned that the symposia be held annually. The fourth symposium is scheduled for January 17-19, 1977, in Los Angeles. Four of the twenty papers presented at the third symposium have been selected for publication in this special section. 1 Each paper was refereed in the customary fashion and each of the papers appearing here is a revised or extended version of the original paper or extended abstract included in the Conference Record. The papers address a variety of topics, yet they have in common a blend of both theoretical and pragmatic considerations. Two of the papers discuss techniques for program transformations. (Indeed, program transformation was an important theme at the symposium.) Baker presents an algorithm for transforming a program in which the flow of control may not be represented by structured-programming-style syntax into a computationally equivalent program which is more readable because the iterative and conditional structure is explicit. An implementation of the technique is described in which Fortran programs are transformed to a structured Fortran dialect. The paper by Loveman discusses the transformation of programs to equivalent programs in the same language which require less running time and/or less space. He illustrates a number of these transformations and describes several programming systems in which the source-to-source techniques have been used. He also argues that appropriate source-to-source transformations can be used to transform a program to a form in which a straightforward code generator could produce the sort of code now generated by conventional optimizing compilers. Such a technique would simplify the code generation phase of a compiler and would provide the programmer with a source-level description of the optimized program. A different aspect of code generation is the topic of the paper by Aho, Johnson, and Ullman. They study the problem of generating good machine code for so-called straight line source code which contains common subexpressions (i.e. multiple occurrences of the same variables or expressions). They show that under a variety of assumptions, the generation of optimal code sequences is computationally difficult in a certain sense. An analysis of some heuristics for code generation is given which offers insight into the reasons for the complexity and some approaches to generating reasonable code sequences at an acceptable cost. Unlike the other papers, all of which, in some sense, give methods for creating programs from other programs, the paper by Summers investigates methods for creating programs from examples of their behavior. An implementation is described in which, by exploiting the structure embodied in S-expressions, programs in a subset of LISP are synthesized from pairs of S-expressions. In order to achieve timely publication of a special section such as this one, it was necessary to set deadlines for each stage in the process. The cooperation of the authors, the referees, and the editors in meeting these deadlines is gratefully acknowledged.

Papers from the second ACM symposium on principles of programming languages

article Free Access Share on Papers from the second ACM symposium on principles of programming languagesCommunications of the ACMVolume 18Issue 12Dec. 1975 https://doi.org/10.1145/361227.372968Online:01 December 1975Publication History 0citation154DownloadsMetricsTotal Citations0Total Downloads154Last 12 Months1Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF