Foundations of programming languages

I must confess that I have co-authored a book bearing the same title [LMW89] and the first compiler-design book treating the same three language paradigms as the book to be reviewed [WS10]. Thus, I might appear a bit preoccupied, in particular since both books are not cited. The purpose of this book, according to the author, is to introduce you to three styles of programming languages by using them to implement a non-trivial programming language. He starts to realize this purpose by providing Chapter 2 on Syntax including bits on grammars and automata and on parsing and lexing tools. Chapter 3 introduces a virtual machine, JCoCo, tailored towards implementing Python, and shows how a non-trivial subset of Python is translated into JCoCo bytecode. Chapter 4 describes an implementation of JCoCo in Java, intended to teach essentials of object-oriented programming. Chapter 5 introduces functional programming with a short excursion into the lambda-calculus, normal forms, and reduction orders. SML is used as example of a func tional language. The author mixes up referential transparency with a case of non-terminating recursion. SML is explained going through the language features and by implementing a prefix calculator. Chapter 6 describes an SML compiler by giving bytecode sequences for SML language constructs in the same way it was done in Chapter 3. Chapter 7 introduces Prolog. Defining the important notion of unification to be simply a list of substitutions for variables is only half the truth. As applications of Prolog the author shows how to do parsing and type inference in Prolog. All chapters are accompanied by examples and exercises with solutions. The strengths of the book lie in the massive amount of quite interesting and relevant material in Chapters 2 to 8. The weakness of the book is the colloquial and often imprecise writing style. The author is not only imprecise and sometimes plainly wrong, he fails to assign the right weight to concepts of different relevance. For example in Section 1.4.3, which introduces virtual machines. He gives the same weight to the concept of compilation of source code to the intermediate code of a virtual machine, the organizational issue of whether the generated virtual-machine code is externally stored like in Java or internally buried like in Python, and the facts that the Java compiler is called javac and the names of bytecode files end in an .class extension. The book has a lot of colorful graphics to explain concepts. However, there is no legend defining the semantics of the graphics elements, e.g. arrows. In fact, they don’t have a consistent meaning reducing the explanatory value of the figures. Another complaint concerns the author’s treatment of the history of computing. His knowledge appears to be quite cursory, and he doesn’t seem to have spent much effort on improving this. He surprises the reader by viewing the Norwegian mathematicians Abel and Lie as forefathers of Computer Science. Many others, mathematicians, logicians, philosophers could serve this role better. What about Ramon Lull and Gottfried Wilhelm Leibniz? Why doesn’t he mention Ada Lovelace as the first programmer? Austrian-American logician Kurt Godel is missing in his treatment of undecidability. Konrad Zuse is not mentioned as implementor of ¨ the first programmable, fully automatic digital computer. The first relevant machine in the class of stack-based architectures, the Borroughs B5000, an Algol60-machine, introduced in 1961, is not mentioned. Instead, he assigns to Hewlett Packard mainframes, said to have appeared in the 1960s, this pioneering role. However, the HP3000 was only introduced in 1972. The invention of object-oriented languages is first attributed to Wirth and Stroustrup. Fortunately, some pages later, SIMULA 67 and their designers Ole-Johann Dahl and Kristen Nygaard are given some credit. At the end of the book there is a short bibliography. Five of the fifteen entries point to sources for photographs of programming-language pioneers, one to an interview and one to a press release. An enthusiastic reader is left alone on his search for further reading material

Foundations of Programming Languages

This clearly written textbook provides an accessible introduction to the three programming paradigms of object-oriented/imperative, functional, and logic programming. Highly interactive in style, the text encourages learning through practice, offering test exercises for each topic covered. Review questions and programming projects are also presented, to help reinforce the concepts outside of the classroom. This updated and revised new edition features new material on the Java implementation of the JCoCo virtual machine

Action semantics in retrospect

This paper is a themed account of the action semantics project, which Peter Mosses has led since the 1980s. It explains his motivations for developing action semantics, the inspirations behind its design, and the foundations of action semantics based on unified algebras. It goes on to outline some applications of action semantics to describe real programming languages, and some efforts to implement programming languages using action semantics directed compiler generation. It concludes by outlining more recent developments and reflecting on the success of the action semantics project

Theoretical foundations for information representation and constraint specification

Research accomplished at the Knowledge Based Systems Laboratory of the Department of Industrial Engineering at Texas A&M University is described. Outlined here are the theoretical foundations necessary to construct a Neutral Information Representation Scheme (NIRS), which will allow for automated data transfer and translation between model languages, procedural programming languages, database languages, transaction and process languages, and knowledge representation and reasoning control languages for information system specification

Logic-Based Specification Languages for Intelligent Software Agents

The research field of Agent-Oriented Software Engineering (AOSE) aims to find abstractions, languages, methodologies and toolkits for modeling, verifying, validating and prototyping complex applications conceptualized as Multiagent Systems (MASs). A very lively research sub-field studies how formal methods can be used for AOSE. This paper presents a detailed survey of six logic-based executable agent specification languages that have been chosen for their potential to be integrated in our ARPEGGIO project, an open framework for specifying and prototyping a MAS. The six languages are ConGoLog, Agent-0, the IMPACT agent programming language, DyLog, Concurrent METATEM and Ehhf. For each executable language, the logic foundations are described and an example of use is shown. A comparison of the six languages and a survey of similar approaches complete the paper, together with considerations of the advantages of using logic-based languages in MAS modeling and prototyping.Comment: 67 pages, 1 table, 1 figure. Accepted for publication by the Journal "Theory and Practice of Logic Programming", volume 4, Maurice Bruynooghe Editor-in-Chie

Benchmarks of programming languages for special purposes in the space station

Although Ada is likely to be chosen as the principal programming language for the Space Station, certain needs, such as expert systems and robotics, may be better developed in special languages. The languages, LISP and Prolog, are studied and some benchmarks derived. The mathematical foundations for these languages are reviewed. Likely areas of the space station are sought out where automation and robotics might be applicable. Benchmarks are designed which are functional, mathematical, relational, and expert in nature. The coding will depend on the particular versions of the languages which become available for testing

FOAL 2004 Proceedings: Foundations of Aspect-Oriented Languages Workshop at AOSD 2004

Aspect-oriented programming is a paradigm in software engineering and FOAL logos courtesy of Luca Cardelli programming languages that promises better support for separation of concerns. The third Foundations of Aspect-Oriented Languages (FOAL) workshop was held at the Third International Conference on Aspect-Oriented Software Development in Lancaster, UK, on March 23, 2004. This workshop was designed to be a forum for research in formal foundations of aspect-oriented programming languages. The call for papers announced the areas of interest for FOAL as including, but not limited to: semantics of aspect-oriented languages, specification and verification for such languages, type systems, static analysis, theory of testing, theory of aspect composition, and theory of aspect translation (compilation) and rewriting. The call for papers welcomed all theoretical and foundational studies of foundations of aspect-oriented languages. The goals of this FOAL workshop were to: � Make progress on the foundations of aspect-oriented programming languages. � Exchange ideas about semantics and formal methods for aspect-oriented programming languages. � Foster interest within the programming language theory and types communities in aspect-oriented programming languages. � Foster interest within the formal methods community in aspect-oriented programming and the problems of reasoning about aspect-oriented programs. The papers at the workshop, which are included in the proceedings, were selected frompapers submitted by researchers worldwide. Due to time limitations at the workshop, not all of the submitted papers were selected for presentation. FOAL also welcomed an invited talk by James Riely (DePaul University), the abstract of which is included below. The workshop was organized by Gary T. Leavens (Iowa State University), Ralf L?ammel (CWI and Vrije Universiteit, Amsterdam), and Curtis Clifton (Iowa State University). The program committee was chaired by L?ammel and included L?ammel, Leavens, Clifton, Lodewijk Bergmans (University of Twente), John Tang Boyland (University of Wisconsin, Milwaukee), William R. Cook (University of Texas at Austin), Tzilla Elrad (Illinois Institute of Technology), Kathleen Fisher (AT&T Labs�Research), Radha Jagadeesan (DePaul University), Shmuel Katz (Technion�Israel Institute of Technology), Shriram Krishnamurthi (Brown University), Mira Mezini (Darmstadt University of Technology), Todd Millstein (University of California, Los Angeles), Benjamin C. Pierce (University of Pennsylvania), Henny Sipma (Stanford University), Mario S?udholt ( ?Ecole des Mines de Nantes), and David Walker (Princeton University). We thank the organizers of AOSD 2004 for hosting the workshop