Principles Of Programming Languages Research Articles

Quantum Patterns and Types for Entanglement and Separability

As a first step toward a notion of quantum data structures, we introduce a typing system for reflecting entanglement and separability. This is presented in the context of classically controlled quantum computation where a classical program controls a sequence of quantum operations, i.e. unitary transformations and measurements acting on a quantum memory. Abstract models for such quantum computations are the Quantum Random Access Machine (QRAM [E. Knill, Conventions for Quantum Pseudocode, LANL report LAUR-96-2724, 1996]) and the Classically-Controlled Quantum Turing Machine (CQTM [S. Perdrix, Ph. Jorrand, Classically-Controlled Quantum Computation, arXiv:quant-ph/0407008, to appear in Mathematical Structures in Computer Science]). Several quantum programming languages follow this model [S. Bettelli, T. Calarco, L. Serafini, Toward an architecture for quantum programming, Eur. Phys. J. D 25 (2) (2003) 181–200, S.J. Gay, R. Nagarajan, Communicating quantum processes, Proceedings of the 32nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, Jens Palsberg and Martin Abadi (Eds.), POPL 2005, January 12–14, 2005, pp. 145–157, M. Lalire, Ph. Jorrand, A process algebraic approach to concurrent and distributed quantum computation: operational semantics, Proceedings of the 2nd International Workshop on Quantum Programming Languages, 2004, pp. 109–126, J.W. Sanders, P. Zuliani, Quantum Programming, Mathematics of Program Construction, Springer LNCS 1837, 80–99, 2000, P. Selinger, Towards a Quantum Programming Language, Mathematical Structures in Computer Science 14 (4) (2004) 527–586]. Among them, the functional language defined by Valiron [B. Valiron, Quantum Typing, Proceedings of the 2nd International Workshop on Quantum Programming Languages, 2004, pp. 163–178] is the basis for the language developed in this paper. This is work in progress.

VyrdMC: Driving Runtime Refinement Checking with Model Checkers

This paper presents VyrdMC, a runtime verification tool we are building for concurrent software components. The correctness criterion checked by VyrdMC is refinement: Each execution of the implementation must be consistent with an atomic execution of the specification. VyrdMC combines testing, model checking, and Vyrd, the runtime refinement checker we developed earlier. A test harness first drives the component to a non-trivial state which serves as the starting state for a number of simple, very small multi-threaded test cases. An execution-based model checker explores for each test case all distinct thread interleavings while Vyrd monitors executions for refinement violations. This combined approach has the advantage of improving the coverage of runtime refinement checking at modest additional computational cost, since model checkers are only used to explore thread interleavings of a small, fixed test program. The visibility and detailed checking offered by using refinement as the correctness criterion differentiate our approach from simply being a restricted application of model checking. An important side benefit is the reduction in program instrumentation made possible if VyrdMC is built using a model checker with its own virtual machine, such as Java PathFinder [Guillaume Brat, Klaus Havelund, Seung-Joon Park, and Willem Visser. Model Checking Programs. In IEEE International Conference on Automated Software Engineering (ASE), September 2000]. We are investigating the use of two different model checkers for building VyrdMC: Java PathFinder, an explicit-state model checker and Verisoft, a “stateless” model checker [P. Godefroid. Model Checking for Programming Languages using VeriSoft. In Proceedings of the 24th ACM Symposium on Principles of Programming Languages, pages 174–186, Paris, January 1997].

A compiler tutorial scaled for the programming languages course

This paper describes the structure of two, self-paced, language-translation tutorials that integrate nicely into a principles-based undergraduate programming languages course, thus bringing material normally covered in a compiler course down into the context of a traditional programming languages course. The primary goal of the tutorials is to provide students with useful models for programming language principles as well as a very basic introduction to compiling techniques, including tokenizing, parsing, static semantic checking, and code generation. The paper also exposes a pedagogic technique of repeated exposure that drives the success of these tutorials.

An Applicative Control-Flow Graph Based on Huet's Zipper

We are using ML to build a compiler that does low-level optimization. To support optimizations in classic imperative style, we built a control-flow graph using mutable pointers and other mutable state in the nodes. This decision proved unfortunate: the mutable flow graph was big and complex, and it led to many bugs. We have replaced it by a smaller, simpler, applicative flow graph based on Huet's [Huet, Gérard, 1997. The Zipper. Journal of Functional Programming, 7(5):549–554. Functional Pearl] zipper. The new flow graph is a success; this paper presents its design and shows how it leads to a gratifyingly simple implementation of the dataflow framework developed by [Lerner, Sorin, David Grove, and Craig Chambers. 2002. Composing dataflow analyses and transformations. Conference Record of the 29th Annual ACM Symposium on Principles of Programming Languages, in SIGPLAN Notices, 31(1):270–282].

Supporting Function Calls within PELCR

In [M. Pedicini and F. Quaglia. A parallel implementation for optimal lambda-calculus reduction PPDP '00: Proceedings of the 2nd ACM SIGPLAN international conference on Principles and practice of declarative programming, pages 3–14, ACM, 2000, M. Pedicini and F. Quaglia. PELCR: Parallel environment for optimal lambda-calculus reduction. CoRR, cs.LO/0407055, accepted for publication on TOCL, ACM, 2005], PELCR has been introduced as an implementation derived from the Geometry of Interaction in order to perform virtual reduction on parallel/distributed computing systems.In this paper we provide an extension of PELCR with computational effects based on directed virtual reduction [V. Danos, M. Pedicini, and L. Regnier. Directed virtual reductions. In M. Bezem D. van Dalen, editor, LNCS 1258, pages 76–88. EACSL, Springer Verlag, 1997], namely a restriction of virtual reduction [V. Danos and L. Regnier. Local and asynchronous beta-reduction (an analysis of Girard's EX-formula). LICS, pages 296–306. IEEE Computer Society Press, 1993], which is a particular way to compute the Geometry of Interaction [J.-Y. Girard. Geometry of interaction 1: Interpretation of system F. In R. Ferro, et al. editors Logic Colloquium '88, pages 221–260. North-Holland, 1989] in analogy with Lamping's optimal reduction [J. Lamping. An algorithm for optimal lambda calculus reduction. In Proc. of 17th Annual ACM Symposium on Principles of Programming Languages. ACM, San Francisco, California, pages 16–30, 1990]. Moreover, the proposed solution preserves scalability of the parallelism arising from local and asynchronous reduction as studied in [M. Pedicini and F. Quaglia. PELCR: Parallel environment for optimal lambda-calculus reduction. CoRR, cs.LO/0407055, accepted for publication on TOCL, ACM, 2005].

Dynamic Partitioning in Linear Relation Analysis: Application to the Verification of Reactive Systems

We apply linear relation analysis (P. Cousot and N. Halbwachs, in 5th ACM Symposium on Principles of Programming Languages, POPL'78, Tucson (Arizona), January 1978s N. Halbwachs, Y.E. Proy, and P. Roumanoff, Formal Methods in System Design, Vol. 11, No. 2, pp. 157–185, 1997) to the verification of declarative synchronous programs (N. Halbwachs, Science of Computer Programming, Special Issue on SAS'94, Vol. 31, No. 1, 1998). In this approach, state partitioning plays an important role: on one hand the precision of the results highly depends on the fineness of the partitionings on the other hand, a too much detailed partitioning may result in an exponential explosion of the analysis. In this paper, we propose to dynamically select a suitable partitioning according to the property to be proved. The presented approach is quite general and can be applied to other abstract interpretations.

Completeness of Continuation Models for λμ-Calculus

We show that a certain simple call-by-name continuation semantics of Parigot's λ μ -calculus is complete. More precisely, for every λ μ -theory we construct a cartesian closed category such that the ensuing continuation-style interpretation of λ μ , which maps terms to functions sending abstract continuations to responses, is full and faithful. Thus, any λ μ -category in the sense of L. Ong (1996, in “Proceedings of LICS '96,” IEEE Press, New York) is isomorphic to a continuation model (Y. Lafont, B. Reus, and T. Streicher, “Continuous Semantics or Expressing Implication by Negation,” Technical Report 93-21, University of Munich) derived from a cartesian-closed category of continuations. We also extend this result to a later call-by-value version of λ μ developed by C.-H. L. Ong and C. A. Stewart (1997, in “Proceedings of ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, Paris, January 1997,” Assoc. Comput. Mach. Press, New York).

Quantitative program logic and expected time bounds in probabilistic distributed algorithms

In this paper we show how quantitative program logic (Morgan et al., ACM Trans. Programming Languages Systems 18 (1996) 325) provides a formal framework in which to promote standard techniques of program analysis to a context where probability and nondeterminism interact, a situation common to probabilistic distributed algorithms. We show that overall expected time can be formulated directly in the logic and that it can be derived from local properties of components. We illustrate the methods with an analysis of expected running time of the probabilistic dining philosophers (Lehmann and Ravin, Proc 8th Annu. ACM. Symp. on principles of Programming Languages, ACM, New York, 1981, p. 133).

Guest editorial

The Eighth International Workshop on Foundations of Object-Oriented Languages (FOOL 8) was held on January 20, 2001, colocated with the ACM Symposium on Principles of Programming Languages in London. Kathleen Fisher chaired the program committee. Six contributed papers were presented. After the workshop, extended versions of three were solicited for this special issue of TOPLAS ; the two articles that were ultimately submitted were reviewed, revised, and accepted following standard TOPLAS procedures.The special issue opens with Type-Preserving Compilation of Featherweight Java by Christopher League, Zhong Shao, and Valery Trifonov. The goal of the authors is to establish a foundation for certifying compilation of Java-like class-based languages. To this end, the authors give an encoding of core Java features in a typed intermediate language suitable for use within a type-preserving compiler. Because of its intended use, the authors focus on developing an efficient encoding. They show that the type erasure of their implementation matches the standard vtable self-application semantics of message sending.The authors use Featherweight Java (FJ), which models the core features of Java, as their source language. Their translation targets a variant of F ω , already implemented as part of the SML/NJ compiler, using its row polymorphism and existential and recursive types to encode FJ. The authors show that the translation from FJ to their target preserves types.In the issue's second article, More Dynamic Object Reclassification: Fickle II , Sophia Drossopoulou, Ferruccio Damiani, Mariangiola Dezani-Ciancaglini, and Paola Giannini explore the issue of dynamic reclassification, by which an object changes its class membership at runtime while retaining its identity. This ability helps model real-world situations where an object has different roles over time---for example, a person who is first a student and then graduates to become a teacher.The authors focus their study on the design of a language, Fickle II , which extends an imperative, typed, class-based, object-oriented language with a reclassification operation. To specify the behavior of their language, the authors give an operational semantics. They then develop a type and effect system and show that the type system is sound, in the sense that a well-typed program cannot get stuck under the operational semantics.We would like to thank our colleagues who served on the FOOL 8 program committee and those who participated in the anonymous reviewing process for TOPLAS . Their efforts contributed greatly to the quality of this special issue.

Minimizing Buffer Requirements under Rate-Optimal Schedule in Regular Dataflow Networks

Large-grain synchronous dataflow graphs or multi-rate graphs have the distinct feature that the nodes of the dataflow graph fire at different rates. Such multi-rate large-grain dataflow graphs have been widely regarded as a powerful programming model for DSP applications. In this paper we propose a method to minimize buffer storage requirement in constructing rate-optimal compile-time (MBRO) schedules for multi-rate dataflow graphs. We demonstrate that the constraints to minimize buffer storage while executing at the optimal computation rate (i.e. the maximum possible computation rate without storage constraints) can be formulated as a unified linear programming problem in our framework. A novel feature of our method is that in constructing the rate-optimal schedule, it directly minimizes the memory requirement by choosing the schedule time of nodes appropriately. Lastly, a new circular-arc interval graph coloring algorithm has been proposed to further reduce the memory requirement by allowing buffer sharing among the arcs of the multi-rate dataflow graph. We have constructed an experimental testbed which implements our MBRO scheduling algorithm as well as (i) the widely used periodic admissible parallel schedules (also known as block schedules) proposed by Lee and Messerschmitt (IEEE Transactions on Computers, vol. 36, no. 1, 1987, pp. 24---35), (ii) the optimal scheduling buffer allocation (OSBA) algorithm of Ning and Gao (Conference Record of the Twentieth Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, Charleston, SC, Jan. 10---13, 1993, pp. 29---42), and (iii) the multi-rate software pipelining (MRSP) algorithm (Govindarajan and Gao, in Proceedings of the 1993 International Conference on Application Specific Array Processors, Venice, Italy, Oct. 25---27, 1993, pp. 77---88). Schedules generated for a number of random dataflow graphs and for a set of DSP application programs using the different scheduling methods are compared. The experimental results have demonstrated a significant improvement (10---20%) in buffer requirements for the MBRO schedules compared to the schedules generated by the other three methods, without sacrificing the computation rate. The MBRO method also gives a 20% average improvement in computation rate compared to Lee's Block scheduling method.

Argos: an automaton-based synchronous language

Argos belongs to the family of synchronous languages, designed for programming reactive systems: Lustre (Proceedings of the 14th Symposium on Principles of Programming Languages, Munich, 1987; Proc. IEEE 79(9) (1999) 1305), Esterel (Sci. Comput. Programming 19(2) (1992) 87), Signal (Technical Report, IRISA Report 246, IRISA, Rennes, France, 1985). Argos is a set of operators that allow to combine Boolean Mealy machines, in a compositional way. It takes its origin in Statecharts (Sci. Comput. Programming 8 (1987) 231), but with the Argos operators, one can build only a subset of Statecharts, roughly those that do not make use of multi-level arrows. We explain the main motivations for the definition of Argos, and the main differences with Statecharts and their numerous semantics. We define the set of operators, give them a perfectly synchronous semantics in the sense of Esterel, and prove that it is compositional, with respect to the trace equivalence of Boolean Mealy machines. We give an overview of the work related to the definition and implementation of Argos (code generation, connection to verification tools, introduction of non-determinism, etc.). This paper also gives a set of guidelines for building an automaton-based, Statechart-like, yet perfectly synchronous, language.

Optimizing multiple EDA tools within the ASIC design flow

Selecting a single register transfer level (RTL) coding style-one that maximizes the performance of simulation, Boolean equivalence, and model checking while achieving an optimal flow through synthesis and physical design-is a formidable task. To reconcile competing tool-coding requirements, the Hewlett-Packard Richardson VLSI Lab has developed a coding style and a design flow methodology that incorporates modern programming language principles. Using the principles of information hiding, abstraction, and encapsulation on all functional grouping of state elements (and other objects), our engineers can focus on design functionality rather than on each individual electronic design automation (EDA) tool's optimal coding style requirement. Building on these principles, we have developed a design methodology to automate the generation of tool-specific libraries. This methodology, which optimizes multiple process points within the application-specific integrated circuit (ASIC) design flow, has several advantages: It permits a seamless optimization of design processes throughout the course of design and enables augmentation of new processes. It leaves the designer's text and functional intent undisturbed throughout the design's duration. It offers cooperation and support for multiple EDA tools while achieving higher verification coverage in minimal time. Finally, our approach clarifies the design intent at the RTL, increases design productivity, and raises the abstraction level without forcing the designer to adopt a new hardware description language (I-IDL).

Programming language methods in computer security

This invited talk will give a personal view of the field of computer security and summarize some ways that methods from the study of programming language principles can be applied to problems in computer security. Some background information is provided here in this short document.

10.1109/FBIE.2009.5405854

Recent advances in atomic modalities and random information do not necessarily obviate the need for online algorithms. Given the current status of low-energy information, scholars clearly desire the deployment of superblocks, which embodies the confirmed principles of programming languages. Using the Boolean logic algorithms and replicated technology, the focus is not on whether sensor networks and extreme programming can cooperate to accomplish this intent, but rather on motivating an algorithm for Boolean logic. In conclusion, the Boolean logic algorithms and replicated technology are proved to be practicable in atomic modalities and random information.

10.1109/IITA.2009.76

Many experts would agree that, had it not been for the analysis of gigabit switches, the simulation of Markov models might never have occurred. Actually, few theorists would disagree with the development of the UNIVAC computer, which embodies the robust principles of programming languages. In research, heterogeneous methodologies are used to prove that cache coherence and journaling file systems are often compatible. In conclusion, it is disconfirmed that link-level acknowledgements can be made multimodal, homogeneous, and large-scale. Analysis is also constructed of forward-error correction.

10.1109/ICCASM.2010.5622325

The investigation of DNS is a compelling quagmire. Given the current status of virtual technology, cryptographers dubiously desire the visualization of access points, which embodies the natural principles of programming languages. Becalm, our new approach for the deployment of thin clients, is the solution to all of these problems. Such a hypothesis might seem perverse but is buffetted by existing work in the field.

10.1109/WCSE.2009.609

Analyzing E-business has been used to analyze the transistor, and current trends suggest that the evaluation of Web services will soon emerge. Given the current status of compact models, cryptographers dubiously desire the improvement of the location-identity split, which embodies the natural principles of programming languages. Using the compact algorithms, it is concluded that the new knowledge-based modalities are explored, which proves to be practicable and useful.

Probabilistic noninterference in a concurrent language1

In previous work (Smith and Volpano, Proceedings 25th Symposium on Principles of Programming Languages, San Diego, CA, 1998, pp. 355–364), we give a type system that guarantees that well-typed multi-threaded programs are possibilistically noninterfer

Formal semantics and interpreters in a principles of programming languages course

Most junior-senior level programming languages courses approach the subject either from the point-of-view of principles (concepts) of programming languages or from the perspective of understanding languages through writing progressively more complex interpreters. In this paper we show how to use formal semantics in a series of interpreter assignments in a principles or concepts-based course. The interpreter assignments make the semantics more concrete for students while providing a deeper understanding of concepts.

A taxonomy for simulation modeling based on programming language principles

ABSTRACT 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.