Book Description:

Concepts of Programming Languages describes the fundamental concepts of programming languages by presenting design issues, examining design choices, and critically comparing design alternatives without being language specific. This book is appropriate for anyone who wants to compare and contrast various programming languages.





Date: 2007-03-07 Rating: 4
Review:
A good book on the design of programming languages
This is not a survey of popular programming languages. Instead, it is a book on the design of programming languages. Of course, the book incorporates a good bit of the history of programming languages as a context for studying the languages of today, so you will see a good deal about languages that for all intents and purposes no longer exist - ALGOL, PL/1, and Simula 67, among others. However, these languages and their design form the basis of modern programming languages. What you'll walk away with after reading this book is a feel for why there are so many programming languages and why they were developed, similarities and differences between programming languages, what is a logical versus a functional versus an imperative programming language, and probably most importantly the decisions and constructs involved in programming language design.

Although this is a good academic textbook on programming languages, I do take exception to the rapidity of new editions. Since 1998, and including the eighth edition that is due in 2007, there have been 5 new editions to this book. I feel that this is taking the idea of publish or perish to the extreme, especially when you note that there are only eight more pages in the planned new eighth edition than there are in the seventh edition. This constant stream of needless new editions is excessively hard on the average student's budget. The following is the table of contents:

1. Preliminaries.
2. Evolution of the Major Programming Languages.
3. Describing Syntax and Semantics.
4. Lexical and Syntax Analysis.
5. Names, Binding, Type Checking, and Scopes.
6. Data Types.
7. Expressions and Assignment Statements.
8. Statement-Level Control Structure.
9. Subprograms.
10. Implementing Subprograms.
11. Abstract Data Types.
12. Support for Object-Oriented Programming.
13. Concurrency.
14. Exception Handling and Event Handling.
15. Functional Programming Languages.
16. Logic Programming Languages.


Date: 2007-02-22 Rating: 4
Review:
Good one...
this textbook was required for my programing languages class... I would say that it is pretty good in terms of breaking things down and I was able to get a better grasp on things and how different language handles different situations. It was definetely useful to me as a hardcore Java developer to get some exposure to different programming languages and to appreciate something that they have and Java lacks.



Date: 2007-02-14 Rating: 4
Review:
Well written and organized text
I bought this book to study for a grad school exit exam, and it got me through the test.

Note that this book is 90+ percent theory. As another reviewer already mentioned - the examples of the various programming languages are only meant to emphasize the concept being discussed, not to teach the language itself. For that you will need supplemental books and/or tutorials. Because more on the languages isn't included in the appendix, as it might have, I reduce the rate from 5 stars to 4.

I think the book also gives software engineers a better appreciation of what's happening behind the scenes -- It's worth the read.


Date: 2006-05-05 Rating: 4
Review:
Best of the easiest, but being dated is showing through
As a perennial instructor of the Programming Languages (PL) course, I have been using Sebesta for a long, long time, having used Pratt's texts before that. There are two categories of books for the PL course: easy and hard. The hard ones snow you with formalism and seem to be proud of the fact that they don't provide motivation. The easy ones are typically boring collections of miscellany with no clear coherence.

Sebesta's seventh edition is the best of the easier category. I think that it would be more helpful to put the history at the end so that samples of programming languages that illustrate the history aren't there for their "snow" value. The examples from history could then be annotated with information taught in earlier chapters. I am happy that context free grammars (CFG) are early in the book, but sad that Chomsky's Hierarchy is neglected, even poorly treated, with assumptions left unstated about CFGs. I generally spend several weeks on automata, since our discrete mathematics course does not get far enough to treat automata, using the excellent tool JFLAP to make the ideas concrete for my students. (Search the web for that tool.) Chomsky's hierarchy is essential to understanding PLs.

I am happy that semantics is early in the book, but sad that it too is so inadequately treated. I spend several weeks on that. Semantics would be an excellent coherence-producing theme of the book, but denotational semantics gets no use in later chapters. It could be used to great profit, for example, to ask what the value of a loop control variable is upon exit from a loop in various languages, where the answer for some languages is, "It's up to the compiler."

Speaking of compilers, most small colleges can't afford to have a separate course in compiler theory, so I supplement Sebesta's scant treatment of compiling.

Finally, the seventh edition is disappointingly dated. Someone should rewrite it from the ground up. One evidence of that is the lack of bibliography entries from the three years prior to its publication. I don't mean just PL research articles. I mean things like the availability of JFLAP, mentioned above. Another evidence of a dated text is the way in which older languages still hang around as examples, but newer languages get shortchanged. SNOBOL4 is said to support pattern matching, but Sebesta neglects to say that patterns are actually a data type distinct from strings in the language, a very modern and mind-stretching idea. Python and Perl examples could provide excellent modern opportunities to illustrate Sebesta's points. Java versus Javascript could illustrate benefits of strong typing or the fact that Javascript's arrays are implemented as hash tables or that Javascript's functions are first-class entities. Given the strong background of our students in Java, many chapters of the book are trivialized, since their content is already known to beginning Java programmers. For example, comparing the "?:" operator with the "if" statement in Java gives an example of functional versus procedural paradigms of programming.

My textbooks in other courses are hard enough that my classroom role is to explain them. Sebesta is so easy as a text that my classroom role is to explain what Sebesta leaves out.


Date: 2006-02-27 Rating: 5
Review:
great comparative analysis of major languages
Sebesta's book is wonderful for his comparative analysis of several common languages. A typical computing book focuses on one language. Which is fine if you need to code in it. But Sebesta lets you step back and see, at a metalanguage view, what characterises a successful language.

The book does not confine itself to the main languages currently in use. You get valuable historical perspective as it walks through the 60s to the present. Hence, we see the development of Fortran, Lisp, Algol, Cobol and Basic. Later followed by Ada and perhaps the most significant object oriented language of all - Smalltalk. While this has never garnered major use, it had pivotal influence on all the OO languages that came later, like C++, Java and C#.

For any computer programmer, the book offers a grand view that should give you more appreciation of your field. Especially by making you aware of other languages and limitations in your language.




[url=http://e45.org/?http://rapidshare.com/files/165549407/ebook.Concepts_of_Programming_Languages.0321330250 .zip]E45.org[/url]