Computing Reviews
Today's Issue Hot Topics Search Browse Recommended My Account Log In
Review Help
Search
Foundations of programming languages
Lee K., Springer Publishing Company, Incorporated, Cham, Switzerland, 2014. 354 pp. Type: Book (978-3-319133-13-3)
Date Reviewed: Jul 20 2015

The philosophical motivation for the structure and substance of the book appears in the preface: predicting what a program will do is important and best achieved when the programmer understands how the language works on the hardware level. This position is then fleshed out so that the reader can understand that object-oriented/imperative programming, functional programming, and logic programming differ because of their underlying computational models. It does this through assembly language, C++, Standard ML (SML), and Prolog.

The book opens with two preliminary chapters that lay out the intellectual foundation of the book. Each one could stand alone as an exposition of the topics treated. The opening chapter distinguishes the three programming paradigms with precision and clarity, and prepares the way for the reader to be able to understand that knowing the paradigm helps with knowing how programs behave. The graphics used to supplement the text are especially well done. What follows is a chapter on representing the syntax of programming languages; it covers Backus-Naur form, context-free grammars, and parsing and parsers. An exemplary feature of this discussion is the caveat that grammars and implemented programming languages are not in a one-to-one correspondence. The inclusion of this limitation is instructive for beginning programmers. These chapters, as do those that follow, include review questions, exercises, and solutions to the practice problems that are interspersed throughout each chapter. Although most of these reinforcing components require only a rote response, many do challenge the reader to think more deeply about the topics addressed.

The next cluster of chapters deals with assembly language, C++, SML, and Prolog. Each of these chapters covers essential concepts with clarity of expression, both verbal and graphical, and each chapter is immersed in specific examples that illustrate those concepts. As throughout the book, the emphasis is on understanding how the surface code relates to the underlying programming paradigm.

The chapter on assembly language does not treat assembly language as a standalone, isolated language; rather, it treats it in terms of bytecode language of the Python interpreter. This strategy illustrates the conceptual unity of the book and the author’s desire to see programming languages in terms of their relationship to the machine-level environment. A fruitful consequence of the approach is that the author is able to treat another programming language in addition to those that have their own chapter. Although a single chapter cannot justly treat assembly language, this one covers both essential constructs such as conditional statements as well as more advanced elements such as lists. The wealth of machine language code presented helps with understanding.

Continuing the strategy employed in the chapter on assembly, the chapter on C++ connects its capabilities and practices to other languages--in this case, Python and Java. These connections help sharpen the reader’s understanding of C++ and these other languages. The chapter elegantly and succinctly covers all the major features of C++, including static type checking, header files, object-oriented programming, polymorphism, templates, and dictionaries. This last topic is developed by comparing C++ and Python dictionaries, which again illustrates that the book is keen on seeing languages as continuous rather than discrete. The attention to bytecode details keeps the reader focused on the levels underlying C++.

SML receives the fullest development of any of the languages included. In addition to discussing it as an example of functional programming, the book devotes a chapter to its compilation details. The chapter connects to earlier chapters by comparing imperative and functional programming and by introducing the lambda calculus, which relates to the chapter on syntax. The chapter includes sections on the major characteristics of SML: functions as first-class objects, strong typing, exception handling, pattern matching, and recursive data structures. The programming practice examples in this chapter are especially useful in illustrating the contours of SML, which is important because many readers will likely come to the book from a purely imperative mindset. Following the treatment of the language, the chapter on compiling SML is especially detailed and the most challenging in the book, but its attention to nuances and sample code help ease the reader to what can be a labyrinth.

Prolog is the last language to have a chapter devoted to it. As with earlier languages, the author devotes time to discussing logic programming and how it differs from other paradigms, and then details its characteristic by treating lists, parsing, built-in predicates, and input-output.

The book concludes with a chapter that develops a type inference system that uses Prolog as the implementation language. Although developing such a system stretches the conceptual boundaries of the book, it is conducted with such clarity and simplicity that readers will find it difficult but rewarding going.

Undergraduates studying programming languages will find this book to be a skillful and informative introduction to the subject.

Reviewer:  Marlin Thomas Review #: CR143629 (1510-0856)
Bookmark and Share
  Featured Reviewer  
 
Formal Definitions And Theory (D.3.1 )
 
 
Language Classifications (D.3.2 )
 
 
Language Constructs and Features (D.3.3 )
 
 
Reference (A.2 )
 
Would you recommend this review?
yes
no
Other reviews under "Formal Definitions And Theory": Date
Higher-order Horn clauses
Nadathur G., Miller D. (ed) Journal of the ACM 31(4): 777-814, 1984. Type: Article
Jul 1 1991
Properties of data flow frameworks
Marlowe T., Ryder B. Acta Informatica 28(2): 121-163, 1990. Type: Article
Aug 1 1992
Programming languages and their definition
Bekic H., Jones C., Springer-Verlag New York, Inc., New York, NY, 1984. Type: Book (9789780387133782)
Jul 1 1985
more...

E-Mail This Printer-Friendly
Send Your Comments
Contact Us
Reproduction in whole or in part without permission is prohibited.   Copyright 1999-2024 ThinkLoud®
Terms of Use
| Privacy Policy