Prateek Mishra

Facile: a symmetric integration of concurrent and functional programming

Facile is a symmetric integration of concurrent and functional programming. The language supports both function and process abstraction. Functions may be defined and used within processes, and processes can be dynamically created during expression evaluation. In this work we present two different descriptions of the operational semantics of Facile. First, we develop a structural operational semantics for a small core subset of Facile using a labeled transition system. Such a semantics is useful for reasoning about the operational behavior of Facile programs. We then provide an abstract model of implementation for Facile: theConcurrent and Functional Abstract Machine (C-FAM). The C-FAM executes concurrent processes evaluating functional expressions. The implementation semantics includes compilation rules from Facile to C-FAM instructions and execution rules for the abstract machine. This level of semantic description is suitable for those interested in implementations.

Type inference with subtypes

We extend polymorphic type inference to include subtypes. This paper describes the following results: •We prove the existence of (i) principal type property and (ii) syntactic completeness of the type checker, for type inference with subtypes. This result is developed with only minimal assumptions on the underlying theory of subtypes. •For a particular “structured” theory of subtypes, those engendered by coercions between type constants only, we prove that principal types are compactly expressible. This suggests that a practical type checker for the structured theory of subtypes is feasible. •We develop efficient algorithms for such a type checker. There are two main algorithms: MATCH and CONSISTENT. The first can be thought of as an extension to the unification algorithm. The second, which has no analogue in conventional type inference, determines whether a set of coercions is consistent.

Operational and algebraic semantics for Facile: a symmetric integration of concurrent and functional programming

We study the semantic foundations of a class of languages that combine the typed λ-calculus with process constructs for synchronised communication over typed channels. Examples include PFL, Amber, PML and Facile, a language under development at Stony Brook that supports a symmetric integration of functional and concurrent programming. Expressions in Facile are very general and may dynamically create processes and cause communication.

DCWPL: a programming language for describing collaborative work

A difficult issue in the development of groupware applications is the specification of control and coordination mechanisms to handle the execution of common tasks on shared resources. The definition of these mechanisms depend on several factors, such as the current group of participants, their shared resources, tasks, and goals. These factors can change dynamically requiring coordination mechanisms to be updated at rtmtime. We propose that a collaborative program be divided into two main components, a computational program that models the shareable artifacts (e.g. pen, blackboard), and a coordination program that specifies the way these artifacts need to be shared. The main advantage of this approach is that coordination programs can be easily modified, often without any change to the computational program. We are developing a coordination language and its runtime interpreter that allows the specification of coordination mechanisms separately from computational programs.

FACILE: A Symmetric Integration of Concurrent and Functional Programming

This dissertation reports the development of a multiparadigm language called Facile that symmetrically integrates an ML-like applicative language with an occam-like concurrent language. The integration is called symmetric because both the functional and the concurrent idioms, and a combination of both are fully supported. The language is higher-order, supporting both function and process abstractions. Processes manipulate data applicatively; expressions in Facile are very general--they may dynamically create processes and communication channels, and cause communication of values. The expressiveness of Facile is shown using a series of examples. The structural static and operational semantics for Facile are presented. In addition, an abstract implementation model of program execution is described. Based on the structural operational semantics, an abstract notion of operational equivalence is formulated. The main result is an extensional notion of program behavior, which is characterized using operational/algebraic techniques. The notion of behavior is parameterized by a set of channels called a window, thus supporting reasoning about programs whose communication interface may dynamically expand during execution, and also reasoning about program behavior with respect to different interfaces. The technique of bisimulation is extended to window-indexed families of relations. The relationship between process equivalence and expression equivalence is explicated. The definition of expression equivalence takes into account both observable effects and resulting value. The relationships between different members of a window-indexed family of equivalence relations are studied. Several important equivalence properties from the original calculi are conserved in this more complex formulation. Some results showing how window-parameterized equivalences may be used in compositional reasoning are presented. A characterization of observationally functional and deterministic Facile programs is provided as a step towards studying restrictions that may simplify reasoning about programs. This dissertation is a preliminary step in studying how the functional and concurrent computational paradigms mesh, with a view towards understanding what properties may be preserved in their integration.

Reasoning about Simple and Exhaustive Demand in Highter-Order Lazy Languages

In this work we describe an innovative strictness analysis method for reasoning about simple and exhaustive demand in higher-order lazy languages. By reasoning about simple demand, we mean determining whether a function requires its input in head normal form whenever its output is so required, i.e., is the function strict? Similarly, by exhaustive demand we mean determining whether a function requires its input in normal form whenever its output is so required, i.e., is the function fully strict?.

On strictness and its analysis

We study the strictness problem for the untyped lambda-calculus and for an ML-like typed calculus. We establish that strictness is a necessary and sufficient condition for the “eager” evaluation of function arguments. For the untyped calculus, we show that the strictness problem is elementary and describe a complete algorithm for strictness analysis of convergent terms. We show that typed terms possess a much richer set of strictness properties. A type-theoretic characterization of strictness is developed and it is shown that the strictness properties of a term can be represented as a collection of types related to the standard term type. A set of type inference rules that support reasoning about strictness related types is given. The inference rules are shown to be invariant under type change by substitution. This provides a sound basis for reasoning about strictness properties of terms by considering only their principal type. For our final result, we describe a practical system that carries out type checking and strictness analysis simultaneously in a unified framework. Our main result is thus the discovery that the problem of strictness analysis is a particular case of type inference.

On the power and limitations of strictness analysis

Strictness analysis is an important technique for optimization of lazy functional languages. It is well known that all strictness analysis methods are <italic>incomplete</italic>, i.e., fail to report some strictness properties. In this paper, we provide a precise and formal characterization of the loss of information that leads to this incompletenss. Specifically, we establish the following characterization theorem for Mycrofts strictness analysis method and a generalization of this method, called <italic>ee-analysis</italic>, that reasons about exhaustive evaluation in nonflat domains: <italic>Mycrofts method will deduce a strictness property for program P iff the property is independent of any constant appearing in any evaluation of P.</italic> To prove this, we specify a small set of equations, called <italic>E-axioms</italic>, that capture the information loss in Mycrofts method and develop a new proof technique called <italic>E-rewriting</italic>. <italic>E</italic>-rewriting extends the standard notion of rewriting to permit the use of reductions using <italic>E</italic>-axioms interspersed with standard reduction steps. <italic>E</italic>-axioms are a syntactic characterization of information loss and <italic>E</italic>-rewriting provides and <italic>algorithm-independent</italic> proof technique for characterizing the power of analysis methods. It can be used to answer questions on completeness and incompleteness of Mycrofts method on certain natural classes of programs. Finally, the techniques developed in this paper provide a general principle for establishing similar results for other analysis methods such as those based on abstract interpretation. As a demonstration of the generality of our technique, we give a characterization theorem for another variation of Mycrofts method called <italic>dd</italic>-analysis.

On the power and limitation of strictness analysis based on abstract interpretation

Strictness analysis based on abstract interpretation is an important technique for optimization of lazy functional languages. It is well known that all strictness analysis methods are incomplete, i.e., fail to report some strictness properties. In this paper, we provide the first precise and formal characterization of the loss of information that leads to this incompleteness. Specifically, we establish the following characterization theorem for Mycroft’s strictness analysis method and its natural generalization to non-flat domains called ee-analysis: Mycroft’s method will deduce a strictness property for program P iff the property is independent of any constant appearing in any evaluation of P. To prove this, we specify a small set of equations called E-axioms, that capture the information loss in Mycroft’s method and develop a new proof technique called E-rewriting. E-rewriting extends the standard notion of rewriting to permit the use of reductions using E-axioms interspersed with standard reduction steps. E-axioms are a syntactic characterization of information loss and Erewriting provides an algorithm independent proof technique for characterizing the power of strictness analysis methods. It can be used to answer questions on completeness and incompleteness of Mycroft’s method on certain natural classes of programs. Finally, the techniques developed in this paper provide a generzd principle for establishing similar results for other strictness analysis methods based on abstract interpretation. As a demonstration of the generality of our technique, we give a characterization theorem for another variation of Mycroft’s method called old-analysis. *Partially supported by NSF grants CCR-8706973, 8805734 Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of the publication and ha date appear, and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise , or to republish, requires a fee and/or specific permission. @ 1990 ACM 089791-419-8/90/0012/0037

Strictness analysis of the untyped l-calculus

1.50 37