Programming Language Theory Research Articles

Using structural theory to make a word-processing manual more understandable

We used Mayer's (1979, 1985) transactional theory of computer programming languages to modify a word-processing manual, that is, we added visual and verbal descriptions of what happened inside the computer for each of 12 commands. In our study, computer-naive adults took a half-day course in word processing. Half of the participants learned from a standard manual that described and provided hands-on activities for 12 basic commands (control group) whereas the other half learned from a supplemented version of a standard manual that included visual and verbal descriptions of the actions inside the computer for each command (conceptual model group). Conceptual-model learners performed significantly better than control learners on tests of problem-solving transfer and retention of basic information. Results indicate that novices benefit from direct instruction about a conceptual model of the to-be-learned system.

Computing with continuous change

A central challenge in computer science and knowledge representation is the integration of conceptual frameworks for continuous and discrete change, as exemplified by the theory of differential equations and real analysis on the one hand, and the theory of programming languages on the other. We take the first steps towards such an integrated theory by presenting a recipe for the construction of continuous programming languages — languages in which state dynamics can be described by differential equations. The basic idea is to start with an untimed language and extend it uniformly over dense (real) time. We present a concrete mathematical model and language (the Hybrid concurrent constraint programming model, Hybrid cc) instantiating these ideas. The language is intended to be used for modeling and programming hybrid systems. The language is declarative — programs can be understood as formulas that place constraints on the (temporal) evolution of the system, with parallel composition regarded as conjunction. It is expressive — it allows the definition of continuous versions of the preemption control constructs. The language is obtained by extending the general-purpose computational formalism of (default) concurrent constraint programming (Default cc) with a single temporal construct, called hence — hence A is read as asserting that A holds continuously beyond the current instant. Various patterns of temporal activity can be generated from this single construct by use of the other combinators in Default cc. We provide a precise operational semantics according to which execution alternates between (i) points at which discontinuous change can occur, and (ii) open intervals in which the state of the system changes continuously. Transitions from a state of continuous evolution are triggered when some condition starts or stops holding. We show that the denotational semantics is correct for reasoning about the operational semantics, through an adequacy theorem.

Strategic directions in software engineering and programming languages

The computer revolution is based on the ability of a general-purpose machine to carry out a specific task under the control of special-purpose software. While the wide applicability of stock hardware has driven demand up and manufacturing cost per unit dramatically down, the same trends have led to increasing demand for ever more complex software for an astounding variety of uses: computer-aided education, improved business processes, what-if financial planning and analysis, new forms of entertainment, fly-by-wire avionics systems, and innumerable others both known and as yet unknown. Producing quality software systems at reasonable cost is an increasingly serious challenge due to ever-growing economic and societal demands. Moreover, software that cannot be modified, updated, or extended becomes useless, due to changes in its technological, social, and economic context. Successful evolution of software systems is a severe technical and managerial challenge that is only exacerbated by the everbroadening kinds of software that must be produced and changed. The techniques and tools that will be needed for efficient and accurate system development, in the face of increasing system complexity and declining life cycles, require deep, new, and exciting scientific and engineering research. The challenges are staggeringly hard, demanding the best efforts of both the programming language and the software engineering research communities. Specifically, we must use impressive advances in programming languages, compiler technology, and software engineering, balancing the beauty of programming language and compiler theory with the messy, ugly, often not entirely technical problems that arise in building and evolving real software. The synergy between software engineering and programming languages and compilers is not merely desirable—it is essential. With hard work, open minds, and appropriate resources, these two communities can apply existing results to make significant progress in bringing science and engineering together to address the challenges of building and evolving diverse software systems. To clarify the potential for synergy between the communities, consider two examples.

Logic activities in Europe

During Fall 1992, thanks to ONR, I had an opportunity to visit a fair number of West European centers of logic research. I tried to learn more about logic investigations and applications in Europe with the hope that my experience may be useful to American researchers. This report is concerned only with logic activities related to computer science, and Europe here means usually Western Europe (one can learn only so much in one semester). The idea of such a visit may seem ridiculous to some. The modern world is quickly growing into a global village. There is plenty of communication between Europe and the US. Many European researchers visit the US, and many American researchers visit Europe. Neither Americans nor Europeans make secret of their logic research. Quite the opposite is true. They advertise their research. From ESPRIT reports, the Bulletin of European Association for Theoretical Computer Science, the Newsletter of European Association for Computer Science Logics, publications of European Foundation for Logic, Language and Information, publications of particular European universities, etc., one can get a good idea of what is going on in Europe and who is doing what. Some European colleagues asked me jokingly if I was on a reconnaissance mission. Well, sometimes a cow wants to suckle more than the calf wants to suck (a Hebrew proverb). It is amazing, however, how di erent computer science is, especially theoretical computer science, in Europe and the US. American theoretical computer science centers heavily around complexity theory. The two prime American theoretical conferences | ACM Symposium on Theory of Computing (STOC) and IEEE Foundation of Computer Science Conference (FOCS) | are largely devoted to complexity theory (in a wider sense of the term). That does not exclude logic. As a matter of fact, important logic results have been published in those conferences. However, STOC and FOCS logic papers belong, as a rule, to branches of logic intimately related to complexity. Finite model theory is a good example of that; see [Fagin 1990, Gurevich 1988] and especially [Immerman 1989]. The di erence between theoretical computer science and the rest of computer science (and computer engineering) is relatively well delineated in this country. In Europe, the line between theoretical computer science and the rest of computer science and engineering is much more blurred, partially because computer science and engineering in general are more theoretical. A much greater proportion of European research goes into programming language theory, semantics, speci cation languages, proof systems, veri cation methods, etc. For brevity and the lack of a better term, I will use the term \formal methods for all of these areas. Europeans put much more faith and e orts into

Semantics of programming languages: structures and techniques

Semantics of Programming Languages exposes the basic motivations and philosophy underlying the applications of semantic techniques in computer science. It introduces the mathematical theory of programming languages with an emphasis on higher-order functions and type systems. Designed as a text for upper-level and graduate-level students, the mathematically sophisticated approach will also prove useful to professionals who want an easily referenced description of fundamental results and calculi. Basic connections between computational behavior, denotational semantics, and the equational logic of functional programs are thoroughly and rigorously developed. Topics covered include models of types, operational semantics, category theory, domain theory, fixed point (denotational). semantics, full abstraction and other semantic correspondence criteria, types and evaluation, type checking and inference, parametric polymorphism, and subtyping. All topics are treated clearly and in depth, with complete proofs for the major results and numerous exercises.

Research directions in computer science: an MIT perspective

This volume celebrates the 25th anniversary of the founding of MIT's Project MAC. It covers the full range of ongoing computer science research at the MIT Artificial Intelligence Laboratory and the MIT Laboratory for Computer Science, both of which grew out of the original Project MAC. Researchers from the faculties and staff of the laboratories highlight current research and future activities in multiprocessors and parallel computer architectures, in languages and systems for distributed computing, in intelligent systems (AI) and robotics, in complexity and learning theory, in software methodology, in programming language theory, in software for engineering research and education, and in the relation between computers and economic productivity. The contributors include: Harold Abelson; Arvind; Rodney Brooks; David Clark; Fernando Corbato; William Dally; Michael Dertouzos; John Guttag; Berthold K.P. Horn; Barbara Liskov; Albert Meyer; Nicholas Negroponte; Marc Raibert; Ronald Rivest; Michael Sipser; Gerald Sussman; Peter Szolovits; John Updike.

Introduction to the theory of programming languages

Introduction to the theory of programming languages

CODIL: The Architecture of an Information Language

This paper describes the CODIL information language in terms of an infinitely recursive model for poorly structured information. This approach is significantly different fron the established approaches to programming language and database theory. The paper then shows how the model has been adapted to work efficiently in the existing CODIL and microCODIL interpreters.

View updating through predefined procedures

A method of view updating is proposed where translation of view updates is explicitly determined by procedures written by the view definer (for example, by a database administrator). Such a procedure is associated with every required kind of view updating. The procedure expresses the user intention associated with a view update and updates stored data. A basic semantic assumption is that a view updating request, combined with the view definition on a syntactic level, is sent as a parameter to a proper procedure. The approach is more realistic than known approaches to the view updating problem, as it may be directly implemented and allows to deal with many reasonable view updates not considered so far in the literature. The idea refers to theory of programming languages and is illustrated in NETUL, a query/programming language for network/semantic data models.

GL—a denotational testbed with continuations and partial continuations as first-class objects

In this paper we describe GL, a language designed to support interactive experimentation with denotational semantics of programming languages, and the novel features of its interpreter. GL is an expressional language that might best be described as an implementation of lambda calculus augmented with several useful basic data types including 1-values.A unique aspect of the GL environment is that it presents a visible, user-accessible implementation of the continuation semantics of GL. The user is expected to understand a denotational definition of GL, and to interact with the system in terms of that definition. In particular, if a computation is temporarily halted the expression continuation extant at that point can be interactively captured and later applied to other values and stores. The implementation of this feature is via a pair of routines called setjmpup and longjmpup that provide what might be called a partial continuation facility. A partial continuation is a function over stores or store/value pairs that represents execution of a partially executed program from its current state to some later state possibly before its half state. The semantics of partial continuations is interesting, and an extension of GL is presented that contains continuations and partial continuations as first-class objects.The GL environment is fairly complete; it has an experimental polymorphic type inference mechanism that supports self-application and report likely sources of user error in a robust manner, and it has a flexible breakpoint and trace facility that permits program execution to be observed and controlled at a variety of levels of granularity. Moreover, it has been used successfully to teach a graduate course in Theory of Programming Languages.

System Semantics and formal circuit description

This paper introduces the concept of system semantics, an extension of the denotational theory of programming languages to the description of arbitrary systems. For a given formal description, different meaning functions describe different properties of interest concerning the system, e.g., structure, behavior, performance. The meaning functions can be made sufficiently simple to serve equally well as rules for formal reasoning and as an actual system description language (SDL) implementation. These principles are first demonstrated in the area of digital systems, which represent the class of systems with unidirectional information flow, and subsequently in the area of analog circuits, where information flow is bidirectional. It is shown how semantic functions can be used to derive properties, ranging from general theorems of circuit theory, expressed as conversion rules in the language, to special conditions for particular circuits, expressed as equations in the meta-language.

Computer science: A challenge to mathematics, or vice‐versa?

In computer science a number of mathematical disciplines are used: Programming language theory and automata theory use mathematical logic, formal systems, algebra, and recursive functions. The study of program structure and program verification uses graph theory as well as some of the above disciplines. The study of computability—'what can we compute and how is it done most efficiently?'‐‐draws heavily on combinatorics and complexity theory. Parallel cooperating programs are described using temporal logic or special temporal graphs called Petri nets.

Designing new languages or new language manipulation systems using ML

The ML language and the denotational theory of programming languages fit together to yield a powerful tool in (new) language design. To effectively support this claim, we give a running definition of a simple Pascal-like programming language with a new and non-standard programming construct. All the provided exemples have been tested on a Unix-4.2BSD implementation of ML.

The place of own variables in programming language theory

An exact definition of the scope of an own variable has not yet evolved. In the past this has given rise to troubles. This paper shows that an assumption that the scope of an own variable does not extend beyond the scope of the owning procedure solves many of the problems and leads to a clearer understanding of their true nature. They are equivalent to additional parameters which have been ‘frozen’ to local generators.

Toward a semiotic theory of programming languages

Based on previous results in a variety of related areas, a schema is described to produce a unified semiotic theory specifically applicable to programming languages. An alternative to BNF-like descriptions is referred to, and the structure of the semantic and pragmatic components is outlined. Programming languages are treated as any other algorithmic notation, and no reference is allowed in the proposed theory to equipment, object code, compiler, or environment.