5 comments about Programming WPF.

1. I say to ignore those reviews because they do not refer to this book. This is the second edition published August 28, 2007 with 863 pages. Those reviews are based off of the first edition published nearly two years before (September 12, 2005) and with only 447 pages.
   
   Using Amazon's 'Search inside this book' takes you to the 2005 edition also. That shows only 10 chapters while this edition has 17. Most of the negative comments from the 2 and 3 star reviewers seem to have been resolved.



2. This book is the most in depth resource into WPF i have seen. And not just that, it gets to the good stuff that you'll actually use in your code and not just filler or lists of properties that you can get from intelisense. The examples are extremely useful.
   
   The other benefit of this book is that it doesn't just tell you how to do things, but why. This is incredibly helpful in finding the best solution to your specific problem.
   
   Thanks guys! great book!
   Ralph



3. I bought the first edition of this book called Programming Windows Presentation Foundation (AKA Avalon) at the PDC in 2005 and read it completely on the plane home.
   
   When I heard the second edition was released I didn't think much would have changed, but this is even better than the first edition. It's twice as big and covers all major (and not so major) topics in WPF (inc. an introduction to 3D and Silverlight).
   
   I think this book will proof to be for WPF what Programming Windows, Fifth Edition is for WIN32 programming.



4. Writing a programming book is not an easy thing to do -- I know, because I've done it myself. And I have to say that I'm really impressed with the job that Chris Sells and Ian Griffiths have done with "Programming WPF". This is one of the best programming books I've ever read (and I've read a lot of them).
   
   For a programming book to be good, it's not enough for it to simply contain all of the information that you need to know. If that information doesn't stick to your brain, then the book hasn't done it's job. If you want the information to stick, then the book has to be interesting to read. It has to have a lot of clear examples that show you real-world applications without extraneous fluff. And to be really effective, all of that should be done with a little bit of style and wit.
   
   And I'm really pleased to say that "Programming WPF" does all of those things. I recently needed a refresher on WPF, so I just spent a lot of time over the last few weeks going through the book very carefully. And I have to say that I'm really impressed. It's engaging, interesting and they chose really good examples. And it's witty! (You'd be amazed at how the occasional chuckle keeps a reader from getting that "eyes glazed over" feeling that far too many books induce.)
   
   I know from experience -- believe me, I know! -- just how hard it is to pull that off. And they did it with style. So first of all, congratulations to Chris and Ian for doing a great job. And second, if you're a C# developer looking for a good, hands-on way to learn WPF, I highly recommend "Programming WPF".



5. I'm almost ashamed to admit that after diving into WPF back when it was known as "Avalon", I haven't even touched WPF since. So I finally needed to suck it up, get started, and learn WPF.
   
   As somebody new to WPF, I just have to give a huge "Thank You" to both Chris and Ian. This book is very entertaining and the quality of the writing between both Chris and Ian is just tremendous. The pace of the book is perfect and the teaching style is one that any developer can relate to.
   
   As a Technical Evangelist working for Microsoft, I think that every "Evangelist" in the tech industry can learn from Chris and Ian on how to tell a compelling story that developers can relate to and "grok". We evangelists are all-too-willing to simply explain the technical details of an API while completely forgetting to answer the "why" (let alone telling a compelling story to suck people in). This is yet another area that this book excels at.
   
   I can say with full confidence that this book is the first book I recommend to anybody wanting to dive into WPF. Enjoy!
   
   Jason Olson, Technical Evangelist, Visual Studio & the .NET Framework
   [...]

1 comments about Operating System Concepts with Java.

1. Currently I am a CS student in my senior year. I am taking my final for the class tomorrow and the book has done an excellent job of taking some complex topics and translating them into legible english. That being said, I will just explain some of the flaws.
   
   The first problem is the pictures or figures in book which are trying to give a visualization of the topics being explained. There a surprising amount of figures in the book that are completely horrid. I mean that they just either further add confusion or are just completely useless. Very shocking because the author/authors are very talented with words, yet seem to very bad when it comes to creating visualizations. There are a few with flat out errors as well.
   
   The second problem is that the questions in the back of each chapter are a catastrophe. The questions are typically just very vague or just aren't very good questions. For instance, there is a question that is similar this
   
   "Does virtual memory need to be supported by the operating system of a handheld system?"
   
   The answer in the teachers guide is apparently "yes". But clearly, this answer is truly "no". Handheld device operating systems don't NEED to support virtual memory. There are plenty of handheld devices that don't, and certainly you don't ever NEED to support alot of things. The question really means to ask "Is it beneficial for a handheld device to support virtual memory?" The obvious answer that is "of course". I got this question wrong on my homework, but myself and a few others talked with the teacher and he quickly agreed that we were right. There are just far too many questions like this that are poorly written.
   
   Regardless of these two problems, the book is really well done.

5 comments about The Rails Way (Addison-Wesley Professional Ruby Series).

1. This seems to have comprehensive coverage of rails/ruby, but may lack the Rails 2.0 coverage I expected. It feels a bit like they threw in some 2.0 updates in order to be able to put "Covers RAILS 2.0" on the cover. Please correct me if I'm wrong!



2. I got this book for a Ruby on Rails class. The class was using Rails 2.0 and this is one of the few Rails books out there that covers Rails 2.0. That was its main highlight. It feels like more of a reference manual than something to learn from. It does seem comprehensive, but it's only good for learning Rails if you already know Rails. It jumps headfirst into complicated topics without explaining why or what for or giving any background. But if you basically already know Rails and just need to look some things up, this book will occasionally be useful.



3. Good reference book for the beginning user. May confuse those that are learning on rails 2.x.



4. This is *the* rails book to get. Even if you're an experienced Rails developer, you'll find loads of great information and advice. The real-world examples are really helpful. Includes an excellent tour through the framework itself. This is one of the few Rails books that covers testing well. Obie is obviously a Jedi.



5. I picked this up purely on the basis of Zed Shaw's endorsement of Mr. Fernandez as one of the few non-stupid Rails proponents out there, and for the most part I'd agree with these sentiments. While it is completely unsuitable for anyone who is completely new to web development or the Ruby language, it is very suitable for anyone else who wants to skip all the evangelical sycophantry that plagues other Rails related titles and jump straight into the meat of the framework.
   
   I still don't like a lot of things about Rails, and I don't like a lot of things about this book, but it is by far the least painful way to get acquainted with the project I've seen to date, allowing the reader to formulate their own educated opinion on these matters relatively quickly.

5 comments about Murach's ASP.NET 3.5 Web Programming with VB 2008.

1. An innovative and exciting website is a great way to attract customers. "Murach's ASP.NET 3.5: Web Programming with VB 2008" is a highly complete and comprehensive training and reference guide to those seeking to have total mastery over the program to better assist their company. It covers how to create one's own program from scratch using Visual Basic 2008 and using ASP.NET features to enhance one's own programs and how to do it professionally. Enhanced with an index and appendixes which cover the changes Windows Vista brought to the to field, "Murach's ASP.NET 3.5" is a must for community library computer collections.



2. Outstanding !!
   Product was exactly what we expected.
   Service was great, we ordered, you responded, Book was delivered (much quicker than we expected).



3. Considering 2 of the other 3 reviewers have rated every book they have rated as a 5 star rating and one of those has only rated Murachs books....I would suggest you throw them out.
   
   On top of that, had I caught it before I bought the book, I wouldn't have bought it on principle alone for it appears that Murach is trying to stack the reviews.
   
   As far as the book... Overall, this book has some good information but it is still mediocre at best. I would keep searching....



4. I'm my job I review hundreds of books a year. I only publically comment on the really good ones and this one is super !
   
   If I were going to teach a course on ASP.NET Development in VB, this is the book that I would use. It's complete, well written, up to date with all the latest ASP.NET technology, and aesthetically pleasing !
   
   Joe Stagner
   www.MisfitGeek.com



5. I picked this book up at my local store the price is better than many others on the same scale. The information included is a great start for beginners and will be a nice desk book for people who already know ASP.Net but want to learn 3.5 or need a book that covers a wide array of topics.

2 comments about HTML: Comprehensive Concepts and Techniques, Fourth Edition (Shelly Cashman Series).

1. I haven't got too far, it gives pleasant assignments and lab-projects to learn HTML. I am more interested in CSS and such, but haven't got too far into the book to see if this is covered. I bought this as a textbook for a class in HTML I am taking.



2. This book covers it all. I just wish, as I am a novice to web design, that there were more real life examples to explain the elements. It was very technical and sometimes I got lost in the jargon.

5 comments about Pro JavaScript Techniques (Pro).

1. Book has lots of examples. Many involve using libraries such as Prototype and JQuery. But, if you are not already familiar with using those libraries, the examples will not make much sense. And considering the typos in the straight JavaScript examples, it left me wondering about the validity of the library demos. Written in the style of a blogger where the author expects you to follow a link to a library's web page and then come back before you can understand the example. If I'm paying for a book to cuddle up with to read on a winter's night, I want it to be self contained - and not expect me to reach for the laptop to read up on the syntax of another library. It also didn't even touch upon one of the more difficult to grasp "Pro" techniques - scoping of "this" when using object methods during AJAX callbacks in the author's own code examples or the various libraries he touts.



2. This was an excellent book two years ago, (and still is), but it's now outdated. I bought it based on its nearly five-star rating; I wish I'd done my homework, since I immediately needed to buy other books to supplement this one.



3. Pro JavaScript Techniques by John Resig is probably the best resource on the language I've encountered to date. I'm one of those web developers who has had something of a mental block when it comes to JavaScript. Despite its ubiquity, it always seemed like a toy language to me. It didn't help that JavaScript's syntax plays a bit fast and loose to my tastes, and that virtually all of the other resources on the language I've encountered barely scratched the surface on what the language can actually do. If you're like me - familiar with the basics, but knowing that you're not proficient enough to use it in a professional setting - then this book is for you.
   
   First, the bad news. Like all aPress books I've encountered, this one suffers from a few small, but glaring, editing errors. Small things - variable names that change between examples for no good reason, in-text refrences to things the author didn't mention (no doubt something missed between drafts), that sort of thing - crop up. It's not enough to break the book, but it is annoying.
   
   Also, the first section of the book moves at break-neck speed. While some of it is review, for those of us who have been toiling in web tutorials and older books, a few re-reads are necessary to truly understand what's going on. Thankfully, Resig addresses things in a logical manner, so each topic flows nicely into the next, making returning to those parts as painless as possible.
   
   Finally, in the chapter where he discusses public, private, and privledged object properties and methods, he completely glosses over how private properties and methods function. Instead, he merely tells the user to visit Douglas Crockford's site on the matter. It's a bit of a cop-out, and I figure that since I'm spending ~$30 on the book, the least he can do is briefly condence Crockford's ideas.
   
   All that said, though, the positives outweigh the negatives by far.
   
   Despite the quick pacing of the book, the information (ignoring editing inconsistencies) is delivered in a straightforward manner. Resig addresses most, if not all, of those little things which are important in the real world (testing/debugging, how to work with libraries, how to ensure your code doesn't interfere with someone else's code, etc), but are often ignored in other resources.
   
   In particular, the early chapters (chapters 2 and 3) on dealing with JavaScript objects are well done. While Resig doesn't go into all of the details (most notably with the link to Crockford's site I mentioned earlier), these chapters form the foundation of just about everything you'd want to do with the language. Indeed, these chapters address most of the pitfalls that create those pesky JavaScript errors we've all dealt with before: scope, closures, and context. Understanding how those three concepts work in unison is fundamental towards understanding modern, professional JavaScript as a whole.
   
   Being a JavaScript book, this particular volume visits topics we're most likely all familiar with: DOM scripting, event handling, and even a bit of AJAX. Thanfully, Resig stays true to his mission of creating inobtrusive JavaScript, and keeps his HTML separated from the scripting code. This is a far cry from other self-proclaimed professional tomes that embed their JavaScript function calls within their HTML tags.
   
   To conclude (and reiterate), Pro JavaScript Techniques is the perfect book for those developers caught in the middle. It's a resource aimed at those of us who have had experience with the language, but have never been pointed in the right direction to use it in a professional manner. Despite its annoying flaws, this book fills the rather large gap between beginner's JavaScripting and creating robust AJAX applications. It's worth owning if you ever want to do serious work with the language.



4. John Resig never fails to amaze and his latest book is no exception. I highly recommend it to everyone interested in javascript; it is a must have.



5. I agree with only one other reviewer who commented on the typos, etc. The demo code does not work until you debug it. The first couple of chapters on Javascript code are very good. The chapters on Forms (8) and Lightbox(9) are so poor I stopped reading. I am a jQuery user and admire Resig's contribution, but this book should be skipped.

5 comments about Assembly Language for Intel-Based Computers (5th Edition).

1. A little surprising that no reviews have already appeared on this 5th edition. The previous editions have been some of the definitive texts on the subject and the author is quite well known.
   
   Anyhow, if you have used an earlier edition, much remains unchanged. Intel has gone to great expense to make its microprocessor family largely compatible as each new generation is released. Here is a thorough description of the assembler commands. Giving examples of how to use each. Along with brief assembler programs that illustrate ideas in a chapter. There are generous numbers of section review questions for the student to tackle.
   
   Plus, how C commands are translated into Intel assembler instructions is gone into at great depth. Takes the mystery out of how compilers work. You can follow the mapping from C-level structures to how they are implemented.
   
   Perhaps surprisingly, there is considerable discussion of MS-DOS. You might have thought it was safely dead and gone. But MS-DOS still is present in many legacy applications. For some jobs, you need to know this stuff.



2. Kip's book is an excellent book suitable for textbook purpose as well as table-reference. If I could I would give it 10 stars.
   
   The way the author progresses the material makes it very easy to follow, and very enjoyable to read.
   
   There is no CD comes with the book. But you can freely download the Visual Studio 2005 Express Edition from Microsoft website.
   
   I have another book, Assembly Language Step-by-step: Programming with DOS and Linux (with CD-ROM) by Jeff Duntemann (Paperback - May 24, 2000). Comparing to Kip's book, that book is almost like a joke (no doubt for Jeff's expertise or authority on Assembly language but the way he put stuff in the book makes you feel somewhat stupid).
   
   Get the book, and enjoy the beautiful binary world with Assembly!



3. I have read a lot of programming text books, but I have never seen so much errata before. My fellow classmates and I are amazed at the amount of errors.
   
   It all started early with the book claiming that George Bool invented the Analytical Engine, instead of Charles Babbage.
   
   We also wonder if the author just cranks out new editions and just adds a few things and doesn't update the rest of the book. It took me awhile to figure out the solution to an assignment, right out of the book, that didn't compensate for newer processors(or any processor in recent history). Actually it seems like it hasn't been changed for 7 years or longer or it's just plain errata. So, I was wondering for a long while why my programming assignment would not work. I finally figured out the book was the reason. Later on there was a programming exercise that required adding to existing code in the book, but when adding lines, it would not work. I would get jump too far errors.
   
   This book could use some better organization too. Simply putting related things together in a chapter is not enough. Yes there is an index and appendices, but the organization in the chapters is poor. Better explanation would be great too.
   
   I guess I am just spoiled by Deitel's books. They are great. Too bad they don't have one on x86 Assembly.
   
   This book was supposed to have a cd-rom disc, but I don't think anyone got one. I sure didn't. The files on the cd-rom are required for the programming assignments to work. Luckily you can download the files off the web site. If you figure out that the files might be on the web site and you go there.
   
   Finally, the binding is weak, I had to re-glue mine within a couple of weeks of receiving a new copy. My professor complained about the binding too. It's too thin(or something) to hold up.



4. Having written many 8086 assembly language programs many years ago, and after having used PPC and SPARC chips for a number of years, I decided to purchase this book to refresh my knowledge of Intel assembler. I was very disappointed in the contents of this book. The title would suggest that the subject matter covered relates to writing Intel assembly language perhaps in a platform agnostic manner, however the book should rather be titled "Assembly Language USING MASM for Intel based computers RUNNING WINDOWS". The book does not even seem to acknowledge that there are other OSs apart from Windows that run on Intel based machines, and also makes use of features and peculiarities of the MASM assembler. If you are looking for a text that will assist you in writing assembler using MASM for Intel based machines running Windows then this is it, otherwise stay well clear, and try to find a text that is less partisan.



5. The books its really step by step have very good example and exercises. It covers basically evreything and has a set of table where they cover all the registers and subroutines. It was really helpful while I was taking the class.

No comments about Programming in Visual Basic 2008.

5 comments about The Art of Agile Development.

1. After reaching 100 pages I felt really disappointed. I was looking something more similar to "Beautiful code" but about management. I have found a book without facts and measures but "tips". I think that we [developers, project managers and other animals] should try to move our profession towards a scientific discipline (i.e. hypothesis-measure pairs).
   
   I was looking for something either like "Mythical man-month"/"Peopleware" or the IEEE articles "voice of evidence". I didn't found any of those.
   
   I do not need any tips but real evidence about what development strategies are good/bad and in which conditions. Real data please.



2. This book is very well written and gives a great description of many different types of Agile practices. Although the book centers around XP, I think many of the techniques and practices could be brought over to any of the different Agile disciplines. The book also goes into the all important steps of selling agile practices to those with the money: managers, directors, stake holders, and the customers. This is a very important step! The book is also nice in that it doesn't necessarily have to be read in chapter order. If you need some help on something, it's easy to pick up the details by just going straight to that section - no need to read everything before it to get caught up. All the information in the book can be applied directly. Many of the concerns related to starting up Agile development in a shop are covered very well.



3. In my opinion, this is the best book for someone starting to implement XP. Before this book, other two books on XP practice were "XP applied" and "XP installed".
   Book by James Shore and Shane Warden provides more broad coverage, then previous books, and contains a lot of good advice, what to do, what not do, and how to do what should be done, while going to the path of Agility.
   
   Presentation is based on the XP, but book also shows a more wide perspective, and contains comparison with SCRUM
   
   What I really like in the book
   - Pragmatic approach to XP - In this book, you will not see approach XP as a holy grail - do it either this way, or you are wrong. Instead, authors expand the original definition of the XP from XP Explained by the practices, which they found to work well in real world
   - Its practical focus - It contains a lot of the practical tips (for example, how to implement continuous integration successfully, how to do test-driven development, what is the real meaning of the user stories etc..)
   - Balanced presentation - for each practice there is Q&A section, contraindications and alternative practices.
   - Live style - book is written in clear and engaging language
   
   Quality of book is very high, and I would recommend it to my friends as a best book to read on working in agile/XP style



4. I have about a dozen books on Agile and Lean development and this rapidly became my favorite.
   
   Why: It's advice at the level I can use. Clear solid explanation and methods to understand what to do, what not to do, and most important, why.
   
   It's just incredibly easy to read and use.
   
   I've already bought 2 more copies to share with friends!



5. This book has three parts in it - introduction to agility, guide to extreme programming and afterthoughts. You may want to read this book if you want to set up XP in your team or participate in it. It is mostly beneficial for the developers or project managers to read it.
   
   The first part (Getting Started) is about 40 pages long and just puts you on the right track by discussing what agility means and introducing you to extreme programming. Here is where the authors explain how to determine whether XP is right in your case, what prerequisites are needed and what steps need to be taken to start.
   
   The second part (Practicing XP) takes most of the book, some 300 pages and contains detailed guide to extreme programming. This is where all the XP practices are explained one by one. Each is given a big chapter - Thinking, Collaborating, Releasing, Planning and Developing. Inside each chapter, there is a detailed explanation of the relevant practices.
   
   The last part (Mastering Agility) is again on the smaller side, it takes 40 pages and contains assorted advices along the "rules are there to be broken" lines. Afterthoughts to help you improve XP once you think you have mastered it.
   
   It is therefore safe to say that the book is essentially a guide to XP, and a good one too. The writing style is excellent - information is organized in half a page long self-contained chunks, each chunk covers some concept or answers some question. Because of this, it is really easy to follow the material.
   
   Even better, each chapter is closed with mandatory sections Questions, Results, Contraindications, Alternatives. Questions are indeed short Q&A and the questions were real-life, more often than not I have found mine answered. Results explain what exactly comes out of the discussed practice. Contraindications explain what obstacles there could appear. Alternatives explain what to do whenever you cannot use the discussed practice. Very realistic and informative.
   
   There were a few imaginary tales from the field. You know, the ones that go like
   - "We use XP here", said Alice.
   - "Wow !", said Bob.
   I don't generally like such stories, they make me feel stupid and therefore in my opinion the book (just like any other) could have got without them better. But this is just me.
   
   An extremely practical guide to extreme programming.

5 comments about Programming Language Pragmatics, Second Edition.

1. Every good programmer should know more than one programming language, that much is almost a consensus. But more than that, every programmer should educate himself about programming languages in general, what they mean and how they work. It's important to know at least the major programming paradigms, because they form the "mental model" of computation that is available to a programmer in a language from that paradigm.
   
   And then it's always illustrative to know about the differences in many common languages, to see where different decisions have been made and what are the consequences. To know that certain legacy languages (e.g. C, Fortran) have features that were not designed because they were the "best" option (for some definition of best), but because the design was constrained by what technology was currently available.
   
   This knowledge is not only required of compiler writers. It should be required of every good programmer. Compiler writers, of course, must know this, and probably in more detail. But Scott's book is a good resource about programming languages, in a level of detail that I believe adequate for all programmers.
   
   There are two main kinds of books on programming languages: they are "survey" and "implementation".
   
   Survey books show how things work in a lot of languages, comparing them along the way. Often the comparison gets down to small details that can affect the meaning, or semantics, of similar programs written in these languages. These books contain one individual chapter for every major topic, and inside such a chapter all languages are compared in relation to the topic. For example, one such chapter covers "subroutines" and then compare a host of different languages on how they implement subroutines.
   
   Implementation books are different: they show how to implement many language features, usually by presenting code for interpreters and compilers. The reader doesn't learn that Ada permits nested subroutines, but instead how nested subroutines really work and how to implement them in a language, for example. A very good book of this kind is "Essentials of Programming Languages" by Friedman, Wand & Haynes.
   
   I normally prefer the implementation books. I'm not really interested if Standard Pascal permits functions to be passed as parameters or not; if I do need to write a Standard Pascal compiler I'll look for a reference manual. I much prefer to know how to implement functions as parameters, and be done with it. Comparing minutiae about extant programming languages can sometimes be very enlightening, and sometimes be mostly dull.
   
   Scott's book, however, really shines because it mixes feature descriptions and implementation details in the presentation. It does the usual routine of comparing a lot of different languages, most of the time the more popular ones like C++ and Java, but it then shows how the implementations differ because of differences in features. The book strikes a good balance between "language design" and "implementation" approaches, although it is clearly slanted towards design, and so more of a traditional "survey" book.
   
   It wins over other survey books by including implementation information about almost every topic, and by the clear writing and style. Also, most survey books concentrate on mainstream imperative languages (nowadays C++, Java, C#) and leave other paradigms to chapters at the end. Scott's book is a bit better in this respect: the presentation often includes Common Lisp, Scheme and Standard ML in the comparisons. There are separate chapters about functional and logic programming too, but considerations about functional programming are spread in the whole book. This is important because paradigms change, and a good programmer must be able to adapt.
   
   It's a good reference for language implementors and good education for most programmers. I look forward to the next editions.



2. As a software engineer, I tend to be picky about my books, but this one is very in depth and a good read. You will learn a lot about different programming languages, and why certain languages are better than others for solving different types of prroblems.



3. This is among my favorite computer science books. I read the first edition straight through from cover to cover, even though I had some prior knowledge of the subject. I have since purchased the second edition, which exceeds the high standards set by the first edition. Scott's book would have made the programming languages course I took as an undergraduate much more enlightening, had it existed at the time.



4. Overall, "Programming Language Pragmatics" (PLP) is a very good book. According to the Preface:
   
   "It aims, quite simply, to be the most comprehensive and accurate languages text available, in a style that is engaging and accessible to the typical undergraduate....
   
   At its core, PLP is a book about how programming languages work. Rather than enumerate the details of many different languages, it focuses on concepts that underlie all the languages the student is likely to encounter, illustrating those concepts with a variety of concrete examples, and exploring the tradeoffs that explain why different languages were designed in different ways."
   
   I'm not knowledgeable enough to pass judgment on "the most comprehensive and accurate" part. But, I'm pretty happy about the book meeting the rest of those goals. I read through the book on my own and have only a few significant gripes:
   
   - Chapters 2 (Programming Language Syntax) and 4 (Semantic Analysis) are tough to get through. They're basically trying to teach enough about Alphabets, Languages, Regular Expressions, Context-Free Grammars, Finite Automata and Push-Down Automata for the reader to understand what the rest of the book is based on. I've read Cohen's Introduction to Computer Theory, which is dedicated solely to this material and I still had some trouble. With an instructor in a class to walk through the things, it should be doable. But, for a person reading the book on his own, ugh.
   
   - All of Section III: Alternative Programming Models, seems to depart from the format of the rest of the book (as noted in the Preface) where the author talks about the concepts and then how the different languages implement them. Instead, he focuses on the languages themselves and almost seems to be trying to cram a primer into his text. Since the section seems to be a special case, it wouldn't be so bad except that the languages covered are a bit out of the mainstream and so that degree of depth gets pretty unreadable at times. Again, with a professor around, things would be better.
   
   - At a more pedagogical level, the author has a tendency to merely explain what his example Figures are doing in general terms. The problem is that a lot of the code/pseudocode involves fairly advanced structures in several languages (many of which most people won't have run across). It would have made things a lot easier if he had walked his way through each of those Figures line-by-line and explained what each line did. Once again, this wouldn't be that much of a problem in a normal teaching environment since a professor could do it.
   
   Other than those three things, this is a very good and readable book. I rate it at four stars out of five.



5. Programming Language Pragmatics 2nd Edition (PLP2e) is a fantastic book that covers a great deal of information. It starts with explaining lexing and parsing, and then goes into scope, target machine instructions, control flow, data structures, a number of paradigms, and building a runnable program. It touches on pretty much every aspect of computer programming, and with deep and insightful knowledge.
   
   While it's not as specific as some other books (language specific references, compiler construction texts, etc), it is a great beginning and reference for a wide range of topics. The bibliography of this book is incredible. I have marked a large number of papers/books from the bib that I now want to read in full.
   
   The bonus information on the CD is also very good, including all the source code from the book, extra sections, and links to other resources.