Foundations of Programming Languages

By Seyed H. Roosta

This work contains about 20 percent more material than is needed for a 14-week, one-semester course. This amount of material gives the instructor some freedom in selecting topics while covering the... This description may be from another edition of this product.

• Format: Hardcover
• Language: English
• ISBN: 0534393039
• ISBN13: 9780534393038
• Release Date: August 2002
• Publisher: Course Technology
• Length: 652 Pages
• Weight: 2.68 lbs.
• Dimensions: 1.1" x 7.5" x 9.6"

Customer Reviews

Great Beginner's Book

This book presents a macroscopic overview of programming languages. The book is heavily concept-oriented. Macroscopic, concept-oriented computer science books can best be described as "Concepts Without Details". Some authors, like Seyed Roosta, do a magnificient job with this approach. Of course, every approach to a subject has its trade-offs. Foundations of Programming Languages biggest strength is it's very well-written and conceptually correct, with each chapter flowing well into the next. The layout of the book is fantastic. Its biggest weakness, however, is absence of detail. Why is detail so essential? In order to really understand programming languages and the ways you can talk to a computer, you must dig below the surface depth. But why, even if you read this book, should you read a book that does cover those details? Answers follow... The book focuses on Level 6 of the seven level structure of typical computer systems: High-order languages. It never adventures into Level 3, the Machine Level. This is an important point: The typical function of a compiler is to take code written in a High-order language, at level six, and transform it into machine language, at level three. Understanding how local variables and arguments are pushed onto the stack and that each function call has its own stack frame is useful knowledge, especially when looking at recursion and forward-referencing at the microscopic level. However, theese facts are microscopic in detail. Foundations of Programming Languages does not provide this detail. Another good example of the lack of detail is the coverage of exceptions. The author does not explain unwinding of the stack, in part because the subject depends upon detailed explanation of stack frames, which is absent from the book. Unwinding the stack is notable because it represents an unavoidable performance penalty, however the topic does not necessarily fall into the domain of programming language design and implementation. One topic that does fall into programming language design is the syntactic sugar for providing exception-safe code. Certain language constructs can have an impact on the way a programmer writes exception-safe code. Some languages provide programmers with the ability to invoke an "undo" operation of their choosing -- very robust for exception-safe code. (The try-catch and try-except blocks can be cumbersome.) The author also pays lip-service to the finally clause, which is an often over-looked yet important construct in Java which allows housekeeping code to execute before the stack is unwound. There is no coverage of Phantom Types (as in Haskell), or the usefulness of Singleton object constructs built into the language (as in Scala ("None"/"Some" and "Nil") and Haskell ("Maybe")), or the decision by the language designer to elevate other GoF patterns into the core language (a'la Groovy's abstract base class BuilderSupport), or opaque data types are not discussed as a coherent concept (void pointe