Customer Reviews

Programming Language Design Concepts

5 star:		(0)
4 star:		(0)
3 star:		(1)
2 star:		(2)
1 star:		(0)

 

 

I found reading this book very frustrating for several reasons.

The first reason was that it would explain similar concepts in different programming languages with almost identical text with only a few words changed. It would have been much better if the book was organized to not be just an inventory of the features of the example languages but would contrast their meaning. It also seemed to focus more on the differing syntaxes of the languages instead of the similar or different semantics behind those syntaxes. It also would have been a stronger book if it mentioned concepts that were present in some languages not surveyed by the book.

It was also not very objective and would make value judgements about the languages, usually by praising Ada's attributes and disparaging C and C++.

Another problem that I found was that it had factual errors about C and C++. For example, it made an emphatic point of saying that C++ arrays could only be initialized with constants, which is not true. It also glossed over C++'s references and frequently made no distinction between C and C++.

In its section on parameter passing, it left out several important parameter passing mechanisms such as thunking (there was no mention of this at all) and C++'s non-const reference parameters. Also, it claimed that C had no modularity techniques and was therefore only useful for small projects and ignored the benefits of static functions or variables that can hide the internal structure of algorithms and information.

While I'm most familiar with C and C++, the flaws in this book with those languages made me unable to trust its comments about other languages. The value judgements it made about the quality or usefulness of different languages were both distracting and unhelpful.

I would everyone recommend NOT to buy this book, but to buy 'Programming Language Pragmatics' by Michael L. Scott.

The problem with this book is this:

It has a very practical approach. This would be nice for some class of readers, but the problem is that the title suggest it's about language design & concepts (so theory).

This book tells you e.g. in short what a classes/objects are, and then a lot of examples in different languages how to define classes and work with objects.

The problem is, that it doesn't tell me anything about the core concepts of OO like inheritance and information hiding. Sure it tells me what inheritance is, and how to do this in different languages, but it doesn't tell me the path to inheritance (what was before, why we have it now), so the concept behind the concept is missing.

So I don't read in this book the concepts behind the concepts. What's the history of OO, how we did get here(Algol -> Modula, etc), the philosofy behind those things etc.

If you want to know this and other things you need to read the book I recommend above.

The author cannot hide his bias towards static typing, and fails to appreciate the power of a dynamic language such as Python. The Python case study (Section 16.3, p. 425) has this criticism:

"""
The compiler will not reject code that might fail with a type error, nor even code that will certainly fail, such as:

def fail(x):
... print x+1, x[0]
"""

In fact it is trivial to implement a class X to create an instance x that can be added to an integer and accessed as a sequence, thanks to basic operator overloading. In order to comment on the design of a language, it is prudent to have more than passing knowledge of its semantics.