Truly a terrible book. I have no doubt that Robert Sebesta is an intelligent man but a talented writer he is not. I had to read more than one of his books for my undergraduate courses and I can say from personal experience that to make Sebesta's books required reading is to do a disservice to students who want to learn programming languages. For one, Sebesta believes that to define something is to give one or two sentences in jargonese and be done with it. His books, especially this one, are extremely frustrating to read, because they don't give enough examples. For any one concept he'll gloss over it with a brief jargon-drowned blurb and expect the reader to know what he's talking about. His writing style is especially difficult, because he writes like a pugilist, mechanically pounding out short, dry declarative sentences over and over. His books are dense, airless, humorless and confusing. A horrible writer who write horrible books, avoid them if at all possible.

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.

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.

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.

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.

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.

I just finished using the book for the Programming Language class. Although the book has Ada, Pascal, C++, Java, and C# code examples, you won't learn to program in any of them from reading this book alone. The book's main focus is on the topic of languages design and theory.

Chapter 2 also contain some interesting history of programming languages. The book is also sparsed with interviews of famous CS people, e.g. James Gosling, Bjarne Stroustrup. Quote from Bjarne Stroustrup, "I consider programming of any nontrival program a job for professionals with a solid and broad education, rather than for people with a hurried and narrow training." If you want such a solid and broad education to be a professional, this book is a good starting point.

It appears the author has no idea what is going on with concepts of PLs. For example, he doesn't even touch on the ideas of follow sets and predictive parsing. His coverage of BNF and EBNF is light, at best, and it seems this topical coverage permiates the whole book.

As any CS student or educator knows, "Concepts of" books tend to be dense and difficult to read. This author attempts to make the material more readable at the cost of detail. Unfortunatley, the detail he leaves out is necessary.

I would also argue that the author doesn't have a strong understanding of PLs. The concepts he presents toward the begining on PL evaluation are incomplete. He doesn't fully express all of the important criteria in language evaluation.

Overall, if you are looking for a brief, topical INTRODUCTION to programming languages, this may be the book for you. Otherwise, I wouldn't recommend it.

This is very interesting book in which you can find interesting information about history of programming languages, as well as most relevant consepts used for building language compilers.

The problem of this book is not in the matter that is presented in the book, but in the way it is presented. The biggest problem is in the typos and mistakes made in the text. It is strange that this 6th edition of the book contains so many typos and mistakes.

Regardless the drawbacks that are said before, I recomand this book for buying. Anyone who is interested in programmming and programming languages will surely find interesting information in this book.

I agree with most of the other reviews (good and bad), but I think it really needs to be mentioned that this book is just *full* of typos and bugs. I've never read a computer book or a so-called textbook with so many mistakes. I would recommend against using this book for teaching until they come out with a new edition that is proofread a little better.

This book will not make you understand the basic ideas behind programming languages, and you won't be able to shy away from math as Sebesta's book does. For that, you will need other books.
This book, however is useful inasmuch as it provides a survey of some programming languages. However, it is heavily biased towards imperative programming languages. Even here the balance is wrong, with a lot of Ada and Pascal. IIRC, he forgets to mention Forth, which is old, but a totally different way to program than the other languages.
On the other hand, anything he has to say about any other type of paradigm will be, probably, wrong. For instance, his description of Lisp remains in the 1950s ("interpreted, everything is a list"). He entirely ignores the Common Lisp Object System, which is by far much more advanced that your staple "OOP" language. The Smalltalk environment he shows is Smalltalk-80. Meaning: the environment used *then*. His description of Functional languages is a joke. So one gets the feeling he doesn't know what he is talking about. And he doesn't.
He missed a lot of development that went on in programming language research and their implementation.
He can't get right new developments in programming except things that are mainstream. In the new edition, he approaches Java, as if garbage collection, object orientation and bytecodes were something new (Smalltalk, Common Lisp almost 20 decades ago). If he's missed all that, let's not even begin to talk about the very new breed, like fast-compiling functional languages (Clean, OCaml), languages that allow reflection and metaprogramming (e.g., Maude), languages built for distributed programming (Oz, Erlang), etc.
If you buy this book, it should be only for the value of having a rather general, limited, historical overview of some programming languages. If you really want to learn about the ideas behind a programming language, you should read Structure and Interpretation of Computer Programs (the classic, now updated), and Concepts, Techniques, and Models of Computer Programming (the "new" classic).

This book doesn't do much for the student... What good are exercises without answers? A strong glossary also would help infinitely. You do need a great deal of prior experience in C based languages to really benefit from the examples.

Concepts of Programming Languages by Robert W. Sebesta, Sixth edition is truly a well-written book. Perhaps one of the best books written on this topic. Sebesta has done an exceptional job conveying the topic to the reader, making a complex topic both easy to read and understand. This textbook is good for any college student or professional trying to get a feel of how the most popular programming languages have evolved in the past 4 decades, and what sets these languages apart. Topics in this book range from Zuse's Plankalkul (the first programming language) to how Exception Handling is done in Java and Logic Programming and everything in between. Interviews with some of the pioneers of our time such as James Gosling (the creator of Java) and Bjarne Stroustrup (the designer of C++), and side "History Notes" represent some of the "fun" readings the author has added to this book. Each chapter ends with a brief but concise summary followed by problem sets that assess the important topics covered in the chapter.

Even though this book is targeted for a junior-level programming course, some of the topics are well worth the reading for an advanced programmer or a graduate student. The author starts by giving the reasons behind why such topic needs to be studied:

· To increase capacity to express ideas - the depth at which we can program, just like the way we think, is highly influenced by the expressive power of the language in which we communicate our thoughts.
· Improved background for choosing appropriate language - if you know more about programming languages, you have a better idea what to choose when development time comes.
· Increased Ability to learn new languages - continuous learning in the field of software engineering is very much essential. If one knows the concepts of one programming language, applying those concepts to other language to learn or understand become much simpler and easier.
· Better understanding of the significance of implementation - Someone who knows the implementation details of that language can only fix some programming bugs.
· Overall advancement of computing - For better decisions to be made going forward with computing and software development, one needs to learn from some of the mistakes that gotten us where we are. Things to do or not to do in this relatively new science.
The author starts by giving a very descriptive background on programming languages, starting from Zuse's Plankalkul, the first programming language. Zuse's defined the Plankalkul and wrote many algorithms in the language for a variety of problems. Even thought it was never implemented, Plankalkul paved the way for other programming languages that would follow it. Fortran, LISP, ALGOL 60, COBOL, BASIC and other high-level programming languages would follow over the years and evolve. The author gives the history behind each language, and goes in to a detail description of how each language evolved over the years. Even though chapter 2 gives the background behind most programming languages, the book only covers the most popular and widely used programming languages thereafter, mainly Fortran, C/C++, Ada and Java.

If your goal is not to teach or learn the details of compilers and/or compiler design, chapter 3 and 4 are defiantly for you. There are many books written on compilers, but Sebesta in one chapter covers the main topics of syntax and semantics and in another covers lexical and syntax analysis. Lexical analysis talks about small-scale language constructs, such as names and numeric literals. Syntax analysis deals with the large-scale constructs, such as expressions, statements, and program units. In less than a hundred pages of text, the author explains the background, theory and implementation of syntax and lexical representation and analysis. It wets the reader's appetite enough that if the reader is interested, he or she can follow the course by taking a compiler design course or read the popular Compilers book by A. V. Aho for example.

The author proceeds to talk about naming, binding, type checking and scopes. Various constructs from different programming languages make up this section, with an emphasis on storage binding and variable lifetime. Various storage types (such as static, stack-dynamic variables and heap-dynamic variables) and their corresponding lifetimes along with their implementation in each language are also covered.

The author then goes into the "newer" topics such as Abstract Data Types (ADT's), Object Oriented Programming, Concurrency and Exception Handling. The author firsts discussed the concept of ADT's and conveys to the reader the benefits of abstraction and encapsulation thru examples programs in Ada, C++, Java and C#. The author in its closing remarks adds:

"The two primary features of abstract data types are the packaging of data objects with their associated operations and information hiding."

ADT sets up the stage for what the author talks about next: Object-Oriented Programming. As with the other chapters, the author starts off by touching on the design issues for Object-Oriented languages. The author then goes off and says:

"In this purest model of object-oriented computation, all types are classes. There is no distinction between predefined and user-defines classes"

The important topics of various object-oriented languages such as inheritance, multiple inheritance, type checking and polymorphism, allocation and deallocation of objects, dynamic and static binding are covered and their corresponding implementations are discussed in detail for each object-oriented language such as in C++.

Robert W. Sebesta has done an exceptional job depicting the topic of programming languages. The background, the history, the design issues behind each decision, the implementation of each language, the evaluation of features between the popular languages, the problem sets at the end of the chapter and last but not least, the interviews with pioneers in the computer science world, make Concepts of Programming Languages, sixth edition a great book.

and one of the best computer science books in general. It is very well written and organized, and doesn't get bogged down in minor details and extra information. It gets straight to the point, unlike another programming language book by Ravhi Sethi. The Ravi Sethi book probably has more information, but it's EXTREMELY poorly written/organized and bogged down with useless extra information (I think he just did that to seem smarter than he really is). I learned 5 times as much reading this book, while spending 1/5 of the time reading it (as compared with Sethi's book).

TO ALL COLLEGE PROFESSORS: PLEASE CHOOSE THIS BOOK IN YOUR PROGRAMMING LANGUAGE CLASS, NOT RAVI SETHI'S. PLEASE!!!

This is one of best books of Programming Languages I know. I use it as basic bibliography to teach Programming Languages in a College in Brazil. This book must be compared with the books of Terrence Pratt, Guezzi and Watt among others. This book do not intend to be a book to teach any language like C or Java. This books is a book to explain issues about the design of languages. (Sorry for my english mistakes)

I used this book for a introductory course to graduate students that had no programming experience. This book was not set up for introductory students. You really need to have expericence with programming languages, especially C and Pascal to make heads or tails of this book.
I didn't like the layout...spending the first part of the book telling you what it is going to talk about, and then spending the second part retelling you. In some cases, in exactly the same words....the organization needs some work and the index and glossary were not thorough enough to be of help. I ended up buying two other books on programming languages to help explain this one to me so I could finish the course.
The review questions did nothing to prepare you for the problem sets at the end of each chapter and the problem sets didn't really have examples in the text that you could refer back to. Like I said, it seemed that the book expected you to know more than introductory level.

I used this in school for my PLs class and it was great. The breadth in the content is excellent and the historical points that are made provide a context to understand why exactly certain languages have evolved the way they have today. Great reference even today at my job.

I am using this book for a programming languages course and find it only slightly useful. It places rather too much emphasis on high-level explanations and history of programming languages, and may be of limited use to people who want to get a deeper understanding of the mechanics of designing a language/compiler. The book is clearly sectioned but each section seems to ramble on without a clear focus of where the discussion will lead. Some exercises, especially the ones on evolution of programming languages, seem contrived. There is also a conspicuous absence of regular expressions/automata which is also important to understanding programming languages

I'm a student who studying a computer education in korea. I'm not good at English... But this book was very easy and readable. Statement clearly written. So easy to understand!! It gives me to have a wide scope about the programming language. It was interesting. This book is somethig like a novel. But It is insufficient for current used popular language somethig like java, php...etc

This book was good for my undergrad programming-languages class, but it didn't help us in our study of attribute grammers, nor was the explanation and examples of BNF and EBNF as extensive as they could have been. Also I was dissapointed the examples as they were all very simple (see Chapter 3's section on Denotational Semantics).

It is true that it says some silly stuff about Java - but that seems to be pretty typical of most text books these days.

I have studied many different programming languages with their different features and approaches, but reading this book helped to give me a much better perspective on why different languages do things the way they do. It does a great job of examining the advantages and disadvantages of the different approaches various languages take.

The author has an incredible amount of knowledge of many different languages which enables him to offer a unique perspective on the subject. The book has a good balance between showing how things are done in newer languages like Java and C++ as well as older languages like Fortran and PL1. Not only does the author tell you what is different, he explains the reasons for the differences.

I would say that sometimes the coverage may be too detailed for the average reader. For example, many pages are spent describing loops, but this is something that is very similar in all languages so it should have been covered only very briefly.

I particularly enjoyed the the chapter on the history of programming languages, which explained the origin of all major languages (and several minor ones) including why they were invented and what impact they have had on computer science.

The book was decent. We used it for an intermediate CS class on programming language concepts, and it did the job ok. I thought there was too much emphasis on the history of CS, and not enough on the actual concepts. Thankfully, I had an awesome professor and the class turned out great. Some weak points: lots of people seemed to have trouble with attribute grammars, the book's explanation was not good enough. And there were a few remarks about Java which were completely erroneous.

The concepts were described pretty well but there was too much emphasis on useless programmming languages. Although I realize this is a book on computer programming, they could have tried to make it a little more colorful. A mug shot of dorky computer scientists at the beginning of each chapter is not my idea of effective visual aid.