Customer Reviews

Programming Languages: Concepts and Constructs

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

 

 

I hated this book when it was the assigned text in my programming languages course. But having just graduated with a BS in CS, I went back and looked thru this book after seeing the negative reviews here. After taking courses like compiler and multi-threaded programming, I feel the book does an excellent job of showing how programming languages evolved, and why. Some of the examples are a little abstract(i agree that the quilt example is too hard to follow, and is spread over too many pages), but for a book that is trying to show the reasons languages evolved it does a good job.

Most of the previous comments are either very favourable to the book (i.e. 4 or 5 stars) or completely against it (1 star).

According to me, this book is a fantastic book IF YOU LIKE PROGRAMMING LANGUAGES. These are the languages I use (from time to time) on my Linux box: AWK, Scheme, LISP, C/C++, Java, Python and Ruby. I'm also trying to understand AspectJ, Oz and Erlang. I think this book is made for persons like me who find pleasure discovering and using new programming languages (and paradigms).

I can understand that if you are a professional programmer (i.e. doing it for a living), this book is of (relatively) little value.

Personally, I love this book!

OK, so it has a stupid bear on the cover, but as far as methodical organization it actually falls in mid to upper range for books on this topic. I think it is quite reasonable as far as content, clarity, and organization. It is not overly chatty but friendly and less dry than most. It does not shy away from defining terms which some books do. The previous reviews are shockingly harsh. There is an opening for a concise easy to read book in this area and I think this book is a reasonable start.

I have lived with this book on my shelf for five years, and during that time have gone back to it a number of times, though I have never read it all the way through for reasons the other reviews will surely explain. I have gone back to it because it is wide ranging and the languages it picks are interesting.

Reading it is like having a row of pearls in front of you. Each is clear and self contained, and they are arranged like a necklace would be. The thread between the sentences is missing however, and you have to work hard to supply it yourself.

Some of the examples (e.g. the quilt example in the functional programming section) elucidate the nature of the programming style and this is good. When moving into the specifics of a language however, the pearl trick happens and I don't get what I am looking for. When reading a book like this I want to garner the spirit of a language. If I want syntax I download a language reference.

I have written reviews on compiler books, and this text was mentioned in one of them. Having a copy, I decided I'd review it.

From a compiler writer's point of view, this book is helpful if you need to choose a paradigm for your programming language. If you don't know about the different paradigms, then the book will be even more useful. It covers a lot of topics related to compilers, including abstract syntax trees, tokens and spelling, grammars (inc. context free grammars), language derivations, ambiguities, BNF, and syntax charts.

In terms of programming in general, the following topics are well-covered: structured programs, data types, type checking, recursive types & functions, records, variant records, sets, procedures, functions, parameter passing, scope (both lexical and dynamic), call-by-value vs call-by-reference (and even call-by-value-result), variable declarations, activation records, the stack, and heap memory management. Many of these topics are useful, if not required, for writing a compiler of your own.

Most of the code snippets in the book are written in either Pascal, or C. This was ideal for me because they were the first two languages taught in my comp sci Degree. But not long afterwards, object-oriented programming became popular, and so the languages taught now have changed to OOP ones. If you're learning an OOP language first, you will have to skip past 200 pages before the book starts to cover this paradigm. Not to say that the early pages are wasted, but it'll be a while before the book gets to the point. There's an early introduction to machine language and then assembly language. After learning of these, you will get a better appreciation of the abstractions in modern programming paradigms.

I found this book in a bargain bin for about $5 AUD, new and hardcover and in perfect condition. I got my money's worth, but I haven't given this book a good rating because it's a simple book and generally overpriced. I feel that it's most suited as an intro to programming that you could read in the first few weeks of a comp sci course. I hear that students have paid a lot for this book. I can understand their frustration. The author is a co-writer of the Dragon compiler-book, a technical book that is difficult for most (including me) to understand (even after I'd written a compiler). The book reviewed here, however, is really basic given that the author has a PhD. It's well-written, but is simple enough for anyone to write. If you can pick up a cheap copy, then it's worth it, otherwise you'll be wasting your money.

This book covers procedural (C and Pascal), object-oriented (C++ and Smalltalk), functional (ML and Scheme), and logic (Prolog) programming. It covers not only the ideas involved with writing programs in these languages, but also deals with some aspects of implementing compilers (attribute grammars and typing) and interpreters. At the end of the book, the chapter on lambda calculus prepares the reader for advanced material on type checking.

The one aspect of the book that doesn't stand the test of time is the material on concurrent programming, which uses Ada. These days, it would probably be better to cover concurrent programming using Java or C++ with OpenMP or Threaded Building Blocks instead. This material is more important than ever with the near ubiquity of multicore processors.

This is a good book, and the section on Functional Programming is especially interesting. Almost every other book in this area omits FP. (The Pratt book comes to mind as one guilty of this omission.)

Having said that, I don't believe that I would pay $100+ for this text. Buy it used!

Considering that this book is an inch thick, it really has surprisingly little valuable content. The author does mention a decent number of topics, but usually only in one sentence or excercise; it never seems to be enough to actually learn anything valuable about the topic at hand. It just seems like the information density of the book is too low. Trying to learn from it is like squeezing blood from a turnip. If you want to learn this material, read Programming Language Pragmatics by Michael L. Scott instead--it's far better!

I noticed that Amazon is ordering more copies of this book. How very sad.... Like smallpox, this book could be eradicated if we all got together and decided to do something about it. What Ravi really needed during the writing of this horrific pile of miscommunication were several humans to have attempted to read the book before its publication. In words: an editor. He also might simply consider not using the construct "In Words:". The fact that Ravi must alert the reader ahead of time that he is going to use words to describe something should give you a fairly good idea as to the delightful cadence and pacing he executes throughout. I wish I could post an example of his [his majesty ravi] prose style; but, alas, I think I lit the book on fire along with some old underwear.

While accurate and wide-reaching, this book has very little real information in it. The problems are challenging only if you don't know the language they reference. The book is, however, well written.