This conference was convened "to explicate programming concepts through the development, examination and comparison of various formal models of these concepts" (per the IFIP Working Group 2.2 on Formal Description and Programming Concepts). This collection of 26 papers represents the results of that charge, while the conference itself was characterized by lively discussions and conversations involving all participants, which served to clarify and crystallize critical issues. The editor hopes some of that liveliness will be communicated to the reader.

The Formal Semantics of Programming Languages provides the basic mathematical techniques necessary for those who are beginning a study of the semantics and logics of programming languages. These techniques will allow students to invent, formalize, and justify rules with which to reason about a variety of programming languages. Although the treatment is elementary, several of the topics covered are drawn from recent research, including the vital area of concurency. The book contains many exercises ranging from simple to miniprojects.Starting with basic set theory, structural operational semantics is introduced as a way to define the meaning of programming languages along with associated proof techniques. Denotational and axiomatic semantics are illustrated on a simple language of while-programs, and fall proofs are given of the equivalence of the operational and denotational semantics and soundness and relative completeness of the axiomatic semantics. A proof of Godel's incompleteness theorem, which emphasizes the impossibility of achieving a fully complete axiomatic semantics, is included. It is supported by an appendix providing an introduction to the theory of computability based on while-programs. Following a presentation of domain theory, the semantics and methods of proof for several functional languages are treated. The simplest language is that of recursion equations with both call-by-value and call-by-name evaluation. This work is extended to lan guages with higher and recursive types, including a treatment of the eager and lazy lambda-calculi. Throughout, the relationship between denotational and operational semantics is stressed, and the proofs of the correspondence between the operation and denotational semantics are provided. The treatment of recursive types - one of the more advanced parts of the book - relies on the use of information systems to represent domains. The book concludes with a chapter on parallel programming languages, accompanied by a discussion of methods for specifying and verifying nondeterministic and parallel programs.

The Formal Description of Programming Concepts is the subject of a series of conferences organised by the IFIP Working Group 2.2 under the auspices of the Technical Committee 2 (Programming) of IFIP. This volume contains the 17 papers which were selected by the program committee. As with the previous working conferences, the questions and answers following each presentation of a paper are reported in an ad verbatum style in order to preserve the liveliness and outspokenness of the discussions.

Key ideas in programming language design and implementation explained using a simple and concise framework; a comprehensive introduction suitable for use as a textbook or a reference for researchers. Hundreds of programming languages are in use today—scripting languages for Internet commerce, user interface programming tools, spreadsheet macros, page format specification languages, and many others. Designing a programming language is a metaprogramming activity that bears certain similarities to programming in a regular language, with clarity and simplicity even more important than in ordinary programming. This comprehensive text uses a simple and concise framework to teach key ideas in programming language design and implementation. The book's unique approach is based on a family of syntactically simple pedagogical languages that allow students to explore programming language concepts systematically. It takes as premise and starting point the idea that when language behaviors become incredibly complex, the description of the behaviors must be incredibly simple. The book presents a set of tools (a mathematical metalanguage, abstract syntax, operational and denotational semantics) and uses it to explore a comprehensive set of programming language design dimensions, including dynamic semantics (naming, state, control, data), static semantics (types, type reconstruction, polymporphism, effects), and pragmatics (compilation, garbage collection). The many examples and exercises offer students opportunities to apply the foundational ideas explained in the text. Specialized topics and code that implements many of the algorithms and compilation methods in the book can be found on the book's Web site, along with such additional material as a section on concurrency and proofs of the theorems in the text. The book is suitable as a text for an introductory graduate or advanced undergraduate programming languages course; it can also serve as a reference for researchers and practitioners.

In software engineering there is a growing need for formalization as a basis for developing powerful computer assisted methods. This volume contains seven extensive lectures prepared for a series of IFIP seminars on the Formal Description of Programming Concepts. The authors are experts in their fields and have contributed substantially to the state of the art in numerous publications. The lectures cover a wide range in the theoretical foundations of programming and give an up-to-date account of the semantic models and the related tools which have been developed in order to allow a rigorous discussion of the problems met in the construction of correct programs. In particular, methods for the specification and transformation of programs are considered in detail. One lecture is devoted to the formalization of concurrency and distributed systems and reflects their great importance in programming. Further topics are the verification of programs and the use of sophisticated type systems in programming. This compendium on the theoretical foundations of programming is also suitable as a textbook for special seminars on different aspects of this broad subject.

With this book, readers with a basic grounding in discreet mathematics will be able to understand the practical applications of these difficult concepts. The book presents the typically difficult subject of "formal methods" in an informal, easy-to-follow manner. A "laboratory component" is integrated throughout the text.