Programming Language Design Research Articles

Connectors for mobile programs

Software architecture has put forward the concept of connector to express complex relationships between system components, thus facilitating the separation of coordination from computation. This separation is especially important in mobile computing due to the dynamic nature of the interactions among participating processes. We present connector patterns, inspired in Mobile UNITY, that describe three basic kinds of transient interactions: action inhibition, action synchronization, and message passing. The connectors are given in COMMUNITY, a UNITY-like program design language which has a semantics in category theory. We show how the categorical framework can be used for applying the proposed connectors to specific components and how the resulting architecture can be visualized by a diagram showing the components and the connectors.

Design patterns and language design

Despite many similarities, there are important differences between design patterns and programming language mechanisms. Nevertheless, we can classify patterns in terms of how far they are from becoming actual language features. Treating patterns as mechanisms that are candidates for being language features, rather than treating them as what they are meant to be, can help demystify them. The authors discuss abstraction, design patterns and idioms.

A lambda-calculus for dynamic binding

Dynamic binding is a runtime lookup operation which extracts values corresponding to some “names” from some “environments” (finite, unordered associations of names and values). Many situations related with flexible software assembly involve dynamic binding: first-class modules, mobile code, object-oriented message passing. This paper proposes λ N, a compact extension of the λ-calculus to model dynamic binding, where variables are labelled by names, and where arguments are passed to functions along named channels. The resulting formalism preserves familiar properties of the λ-calculus, has a Curry-style-type inference system, and has a formal notion of compatibility for reasoning about extensible environments. It can encode records and record extensions, as well as first-class contexts with context-filling operations, and therefore provides a basic framework for expressing a wide range of name-based coordination mechanisms. An experimental functional language based on λ N illustrates the exploitation of dynamic binding in programming language design.

Using Ada to teach programming language design concepts

The undergraduate Concepts of Programming Languages course at Texas Tech University is part of an eight-course software engineering-related sequence in the undergraduate curriculum. Previous classes in this sequence make it both easy and natural to discuss software engineering concepts such as software reuse and program verification in this course.This paper discusses research into a revision of this course so that it is primarily centered on the Ada 95 programming language. The robustness and elegant design of Ada make it deal for such a class. Under a grant, a textbook and an instructor's guide have been developed for the Ada 95 portion of the lecture component, and were used at Texas Tech University during the Fall of 1996. The lecture notes and other materials were well-received, and the course was very successful, with an increase in exam, homework, program, and overall course averages (up by over 12%).

A formal approach to the teaching of programming language concepts

While the power of formal semantics is well recognized, it is not usually considered a teaching tool. This paper describes the use of denotational semantics in a course on programming language design for beginning graduate students. The course introduces the semantic and implementation issues underlying such concepts as naming, block structure, scope rules, parameter passing, flow control, and exception handling. The approach taken is to specify the semantics of these mechanisms, using a simplified form of denotational semantics, and use these descriptions as the basis for discussion. Implementations are developed from the specifications, and are available to students for experimentation.

Preface: Volume 16, Issue 3

The HLCL workshops are intended to bring together researchers involved in the design, development, foundations, and applications of high-level concurrent programming languages and models.Programming models should be simple, practical, high-level, and well founded. These qualities allow rigorous language specifications and support both formal and informal reasoning about programs. For concurrent and distributed systems, research on programming models has driven the design of several recent programming languages, including Erlang, versions of ML, like CML, Facile, and Haskell, as well as languages explicitly designed for concurrency or distribution such as Obliq, Oz, Pict, and the Join-Calculus language. Although the motivations behind the design of these languages are diverse (ranging from the development of graphical user interfaces and multi-agent systems to constraint, real-time, and distributed programming), suitable foundations have turned out to be quite similar in style and technique, often based on variants of well-known calculi for mobile processes.The first HLCL Workshop was organized by Benjamin Pierce and Matthew Hennessy at the Isaac Newton Institute for Mathematical Sciences, University of Cambridge, UK, in October 1995. The second HLCL Workshop was organized by Martin Müller and Joachim Niehren at Dagstuhl, Germany, in January 1997, chaired by Kohei Honda, Martin Odersky, Benjamin Pierce, Gert Smolka, and Phil Wadler. For more information see the workshop homepage.In addition to the six contributed papers presented at the workshop, this collection contains an abstract of the invited talk by James E. White (General Magic, US). We would like to thank the authors of the submitted papers, the invited speaker, and the members of the program committee for their contribution to both the meeting and this volume. We also would like to thank BRICS for the printing and Michael Mislove for his help with the editing of the proceedings, ERCIM for financial support, the CONCUR organizing committee at INRIA for hosting HLCL'98, and Silvano Dal-Zilio for further local organization.

The Control Structure Diagram: An Overview and InitialEvaluation

A new graphical representation, the Control Structure Diagram (CSD), has been created to visualize software at both the source code and program design language (PDL) level. The primary impetus for creation of the CSD was to improve the comprehension efficiency of software and, as a result, improve reliability and reduce costs. The CSD has the potential to replace traditional prettyprinted source code. As part of the GRASP (Graphical Representations of Algorithms, Structures, and Processes) research project at Auburn University, the GRASP software engineering tool has been successfully developed. GRASP automatically generates CSDs from source code written in Ada, C, C++, Java, and VHDL. The emphasis to this point has been on the automatic generation of the CSD to support development, maintenance, reverse engineering and reengineering through the use of GRASP. GRASP has been applied successfully to numerous programs ranging in size from several hundred to several thousand lines of source code and is efficient and sufficiently flexible for use in a production setting. To demonstrate the potential benefits of the CSD and its automatic generation using GRASP, a series of empirical studies has been planned and initiated. First, as reported in this article, the perceived usefulness of the CSD was evaluated using a preference instrument based on eleven performance characteristics in which a comparison was made with other well-known graphical representations for algorithms. Statistical analysis indicated numerous significant differences with a clear preference for the CSD in seven of the eleven performance characteristics. Further empirical studies, currently being implemented, will examine the effect of the CSD and GRASP on objective measures such as comprehension efficiency and effectiveness.

Commonality and variability in software engineering

The article describes how to perform domain engineering by identifying the commonalities and variabilities within a family of products. Through interesting examples dealing with reuse libraries, design patterns, and programming language design, the authors suggest a systematic scope, commonalities, and variabilities approach to formal analysis. Their SCV analysis has been an integral part of the FAST (Family-oriented Abstraction, Specification, and Translation) technology applied to over 25 domains at Lucent Technologies.

Object Models for Distributed or Persistent Programming

As use of object orientation for application development has increased, many researchers have investigated the design of object-based programming languages for distributed and persistent programming. This paper concentrates on reviewing a number of such languages for distributed or persistent programming. In each case, the focus is on the object model supported and the mechanisms and policies employed in the implementation of distributed or persistent objects. In particular, each language reviewed has been chosen to illustrate a particular object model or implementation strategy.

“Who cares about elegance?” The role of aesthetics in programming language design

The crucial role played by aesthetics in programming language design and the importance of elegance in programming languages are defended on the basis of analogies with structural engineering, as presented in Billington's The Tower and the Bridge .

Units of Computation in Fault-Tolerant Distributed Systems

We develop a framework that helps in understanding a fault-tolerant distributed system and so aids in designing such systems. We illustrate the uses of the developed work in application areas such as checkpointing and recovery, phase termination detection, stable property detection, implementing membership protocols, debugging, and design of programming languages. We define a unit of computation, and refer to it as a molecule. A molecule has a well defined interface with other molecules. The smallest such unit—an indivisible molecule—is termed an atom. We show that any execution of a fault-tolerant distributed computation can be seen as an execution of molecules/atoms in a partial order, and such a view provides insights into understanding the computation, particularly for a fault-tolerant system where it is important to guarantee that a unit of computation is either completely executed or not at all and system designers need to reason about the states after execution of such units. Molecules are essentially a generalization of atomic actions.

Provably-secure programming languages for remote evaluation

Remote evaluation and dynamically-extensible systems pose serious safety and security risks. Programming language design has a major role in overcoming some of these risks. Important research areas include designing suitable languages for remote evaluation, identifying appropriate security and safety properties for them, and developing provably-sound logics for reasoning about the properties in the context of separate compilation and dynamic linking.

Beyond ML

We believe that the most pressing problem in programming-language design is to control the interference that arises when functional and imperative programming are combined, and to give the user more control of storage allocation, without sacrificing the virtues of higher-order procedures, rigorous typing, and modularity that characterize ML. Towards this end, we intend to pursue research on Algol-like languages, linear typing, and the use of regions for storage allocation.

Foreword: Volume 7

One of the main research objectives of computer science is the development of formal methods for the design and implementation of concurrent programming languages. A most prominent feature of this research area is the proliferation of programming concepts arising from imperative programming, logic programming, functional programming, object-oriented programming, constraint programming, and the various formalizations thereof.The Human Capital and Mobility project EXPRESS has aimed at a general understanding of the interconnections and relations between formal systems for concurrency, ranging from programming languages to axiom systems and rewrite systems. More specifically, we have compared programming concepts and formalisms on the basis of their relative expressive power. The results obtained in our project are steps towards classifying the variety of concurrent programming languages, and may provide a formal basis for their design and implementation.The partners of EXPRESS have been the CWI (Amsterdam), the University of Utrecht, the University of Florence, the University of Aalborg, the University of Nijmegen, the Swedish Institute of Computer Science, the University of Genoa, the University of Rome “La Sapienza”, the University of Hildesheim, the University of Amsterdam, INRIA Sophia Antipolis, INRIA Rennes, and the University of Sussex. External partners associated to the project were the State University of New York at Stony Brook, the University at Cornell (USA), the Weizmann Institute (Israel) and the McGill University (Canada). The project ran for four years 1993-1997.Each year the project partners met at a workshop, disseminating the latest results. The last of these, EXPRESS'97 at Santa Margherita Ligure, Italy, 8-12 September 1997, was also open to the scientific community. Apart from the ordinary EXPRESS presentations we had a general call for papers from outside the project. Among the submissions we selected 13 papers from presentation, which are collected in these proceedings. Additionally we had 7 invited speakers: Ralph Back, Jean-Jacques Levy, Eugenio Moggi, Ugo Montanari, Amir Pnueli, Vaughan Pratt, and Colin Stirling. Some of the invited speakers also offered a contribution to the proceedings.We would like to thank the EXPRESS members, the invited speakers, the authors of the submitted papers, and the members of the program committee for their contribution to both the meeting and this volume. We also would like to thank Elisabetta Ferrando for help with the local organization and Michael Mislove for editorial help with the proceedings.Catuscia Palamidessi, University of Genova, ItalyJoachim Parrow, Royal Institute of Technology, Stockholm, SwedenEXPRESS'97 Programme CommitteeLuca Aceto (Aalborg)Eike Best (Oldenburg)Frank de Boer (Utrecht)Ilaria Castellani (Sophia Antipolis)Philippe Darondeau (Rennes)Rocco De Nicola (Florence)Ursula Goltz (Hildesheim)Jan Willem Klop (CWI)Catuscia Palamidessi (co-chair)(Genoa)Joachim Parrow (co-chair)(Stockholm)Frits Vaandrager (Nijmegen)

Using a programming language for digital system design

HDLs must satisfy important semantic requirements, especially when CAD tools are involved. Designers can meet these requirements by using the standard language constructs of a software-programming language to model hardware for simulation and synthesis.

A position paper on compile-time program analysis

Current challenges to the compile-time analysis research community include unifying the nomenclature in program analysis, embedding analyses in practical software tools, influencing programming language design to allow analysis, and adapting analyses to the blend of architectures, languages and operating systems common in modern software. These challenges must be met to ensure that compile-time analyses will continue to be of practical benefit.

Challenges in type systems research

Type systems are one backbones of programming language design and implementation. Current research addresses questions in fields as diverse as mathematical logic, program analysis, and human factors engineering. Some of the future challenges for the field are: increasing the expressiveness of typed programming languages, broadening the information carried by types, and making type systems amenable to user definition and customization.

Implementing signatures for C++

We outline the design and detail the implementation of a language extension for abstracting types and for decoupling subtyping and inheritance in C++. This extension gives the user more of the flexibility of dynamic typing while retaining the efficiency and security of static typing. After a brief discussion of syntax and semantics of this language extension and examples of its use, we present and analyze three different implementation techniques: a preprocessor to a C++ compiler, an implementation in the front end of a C++ compiler, and a low-level implementation with back-end support. We follow with an analysis of the performance of the three implementation techniques and show that our extension actually allows subtype polymorphism to be implemented more efficiently than with virtual functions. We conclude with a discussion of the lessons we learned for future programming language design.

Provably secure programming languages for remote evaluation

Abstract : Remote evaluation and dynamically extensible systems pose serious safety and security risks. Programming language design has a major role in overcoming some of these risks. Important research areas include designing suitable languages for remote evaluation, identifying appropriate security and safety properties for them, and developing provably sound logics for reasoning about the properties in the context of separate compilation and dynamic linking.

Challenges in type systems research

Type systems are one backbones of programming language design and implementation. Current research addresses questions in fields as diverse as mathematical logic, program analysis, and human factors engineering. Some of the future challenges for the field are: increasing the expressiveness of typed programming languages, broadening the information carried by types, and making type systems amenable to user definition and customization.