No comments about Beginning Programming All-In-One Desk Reference For Dummies (For Dummies (Computers)).

5 comments about Concepts in Programming Languages.

1. While I cannot speak to the quality of Mitchell's course, having only read his book, the earlier criticisms of his use of ML in the book are missing the point of a programming languages class. It's not meant to teach you a random sampling of the 2500+ computer languages that are out there. The idea is to learn about the fundamental paradigms of programming, with a focus on the functional and logical approaches since students are generally already familiar with imperative and object-oriented programming.
   
   ML is one of several good choices for illustrating functional programming, and is actually one of the more popular functional languages (especially the OCaML dialect.) There are many well written books and tutorials on the ML family of languages freely available on the web if you need more examples or detail than he provides in this text. However, the point isn't to learn ML, but rather that once you understand functional programming in any language, you can take advantage of its power, not only in languages like perl and python which offer some limited but nice functional features like map and anonymous functions, but also in imperative languages like C via function pointers and callback techniques.



2. As a grdauate student, I feel compelled to write honestly about this book in the hopes that what I'm writing might influence some teacher's decision in the future. Granted, the topic area this book is covering isn't trivial, but in the light of its complex nature it is even more paramount that someone attempting to explain it to those who don't understand it be well-versed in, frankly, English. This book is quite possibly the worst textbook I have ever encountered. The writing is atrocious, the "flow" is like mud, and the explanations make even things that could be simple, dreadfully complex. Avoid it like the plague, there are a lot better options.



3. The excessive reliance on ML and poor language skills exhibited are well covered in the other reviews. I'd just like to add that Mitchell has a terrible habit of explaining things out of order (for instance, activation records are explained on page 165, but you are expected to know them on page 148), and his "This is beyond the scope of this book." handwaving makes many of the explanations completely incoherent.
   
   I have never sold back a textbook before, but I'm taking this back to the bookstore right after my final, and then I'll get a real Comparative Programming Languages textbook.



4. It's a good review book if you know your material and just need a quick refresh or need the same concept explained differently. However, this book will intimidate you if you're new to computer science. An example would be in Chapter 1, the words "stack memory management and recursive functions or procedures" were thrown at the readers without any explanation.



5. I can't speak to John Mitchell's skill as a lecturer, but some of the complaints here seem to betray a misunderstanding of the purpose of the book: to serve as an introduction to programming language theory, such as can be found in Mitchell's other book *Foundations for Programming Languages*. Mitchell is taking you *out of* the marketable skills zone and into abstract computer science, and he's being pretty nice about it -- the book contains friendly precises of topics like lambda calculus and denotational semantics, which make up the formal core of programming languages. What you will learn has applications in all popular programming languages, even if it's not spelled out in the text.
   
   ML was a good choice as an example language, because it includes many of the features a programming language might have (being both imperative and functional), and furthermore is a serious research language on account of its well-understood semantics and type system. Focusing on it to explain core concepts was not a mistake. Mitchell knows how to do it the other way, too: explanations of the basic elements of object-orientation are parceled out over several notable OO languages, providing a way to compare and contrast how the major OO concepts can be implemented. (I didn't find the final chapter, Apt's summary of Prolog, as helpful: the declarative paradigm is too far removed from what was developed in the rest of the book.)
   
   On account of its relatively gentle explanations and the importance of its concepts for all aspects of CS, this would be a good book for a relative beginner in CS to pick up (provided they can comprehend more than just code). But if you find it too repellent, you're probably not going to be much happier with more advanced treatments: its character just reflects the nature of the field.

3 comments about Sams Teach Yourself C++ in One Hour a Day (6th Edition) (Sams Teach Yourself).

1. I never read the 5th edition of this book, so I can't really remark on the differences with this 6th edition. But considering just this edition...
   
   The book fits well into the style of the series of "Teach Yourself ... in One Hour a Day". Each chapter, which the authors term a lesson, is bite-sized. I can readily envisage a typical neophyte to programming (of any language) being able to assimilate its contents in roughly an hour. Keep in mind that if you have never encountered this series before, then don't take too literally the one hour limit, as far as understanding the text in each chapter. Some chapters will naturally be more important and cover more complex concepts than others. If you need extra time, take it. The shoehorning into an hour is only an approximation.
   
   What might be the simpler chapters? One could be that on controlling program flow, using while, do-while and for loops. The most important item in this chapter is that you should use these constructs whenever possible, in place of goto. Yes, you can use goto in C++. But the book warns that this leads to spaghetti code. Tangled and difficult to debug and extend. Goto is a tempting shortcut to beginners that must be resisted.
   
   A more complicated chapter is on pointers. Describing the some of the myriad ways that they can be used and misused. There is ample warning about pointer errors. The book does not do a comparative analysis with other languages. But you should know that the designers of Java thought pointer bugs in C/C++ were so numerous and miserable that pointer arithmetic has been essentially banned in Java. Yeah, you want to be a C++ programmer; why else would you be considering this book? That's fair enough. But it doesn't hurt to know some of the key differences between C++ and its major alternative, which seems to be Java. If nothing else, this particular difference can keep you focused on very carefully writing pointer code.



2. I just finished chapter 4 managing arrays and strings. The book is well written the examples are error free and best of all the book follows a great structure that's something like;
   
   -lesson,
   -example code,
   -analysis of code,
   -at the end of each chapter there's a summary,
   -Q/A for the main points of the chapter.
   -workshop section with quiz questions and exercises.
   
   The exercises send you out to write your own code from scratch and think outside of the books examples, some of the exercises are labeled BUG BUSTERS which show code snippets with errors for you to solve. Appendix D has quiz answers and possible solutions to the exercises.
   
   So all that gets your mind into the language not just memorizing it, and gives you multiple opportunities to understand each point.
   
   The book includes a free 45day pass to read the book online via "Safari online".
   
   I highly recommend this book!



3. I'm not a big fan of "Teach yourself X in Y amount of time" books. There, I've said it. Most of these books have their timing wrong anyway, you can't learn to be a world class polo player in 24 hours, you can't build your own ocean liner in 21 days and you can't be a professional hula champion in six easy lessons. And you won't be able to teach yourself C++, at least not enough to be of any use, in an hour a day.
   
   But this book works. Forgetting the one hour a day promise, the book works very well. Learning C++, or just C, or any programming language from scratch is hard. Even harder if you have to learn the concepts of programming, loops, branches, pre and post tests and the whole object oriented thing. This book doesn't make it simple, but it does make the process more logical. And it breaks the process into small steps, most easily learned in an hour.
   
   I'm not a C++ guru. I've used Visual Basic for just about ever and only written a few minor projects in C. I can print my name to the screen in C++, but that's about it. Or at least it was until I started this book. Walking through the first section, aptly titled "The Basics," I was able to get moderately familiar with C++ in such a way that I'll retain the knowledge pretty well. Quite obviously I'll get rusty if I don't use the new skills on a routine basis, but learning them was straight forward and well presented. The tutorials are backed by example code that worked fine in several different compilers and the analysis of what the code is doing is very effective at teaching the concepts as well as the specifics.
   
   I do have a few minor complaints about the book. For one, it almost seems like two books. The first two thirds teaches C++ fundamentals and Object Oriented Programming quite effectively. But then the book almost changes direction and dives into the Standard Template Library. To me it's almost as if the book went a few hundred pages long. I suppose with the trend to produce forest-leveling technical books rather than specific shorter, more to the topic books, that this is to be expected. But I'd rather pay $50 for a 120 page book with only the information I needed than $20 for a thousand page book that scattered that same 120 pages across hundreds of pages of irrelevant, at least to me, material.
   
   On the plus side, this book's 800 or so pages aren't padded with repetitive material or fluff just to meet a page count. The contents may not all be relevant to me, but they are likely relevant to someone else who might buy the book. I tend to see quizzes and exercises in a book like this as extra paper I didn't need, but a student with this book as a course text would find the material appropriate. Even for me the exercises provoked a thinking process not contained in the lesson itself. And in the end, you can't truly learn anything, whether it takes an hour a day or ten, unless you use the knowledge outside of the written example. If you want to learn C++, at your own pace, this is an excellent book to have.

5 comments about Foundation PHP for Dreamweaver 8.

1. This is a good book. It teaches many useful techniques and how lots of "how to" ideas. However, the faux site that is created isn't goal oriented which left me feeling like the book was just a collection of random things to do. It seemed disorganized at times when you would or wouldn't create another page from scratch vs. revamping one you had already made. It was not always clear why you would be better to take one approach vs. the other. Setting up the localhost environment was somewhat confusing, though not too bad.
   
   I will definitely use it frequently. Good information, good book, good deal.



2. This man makes a promise of a written format that can be followed. The writtng is NOT CLEAR and leaves much to the readers imagination of to what exactly the format should be. There is no CD so that you can see how the step by step process works. He names his files but does not show the real differences between how he is set up and how you can set up to fit your needs. I waisted my money. He claims in the book there is support which at best is terrible.
   
   The worst book I have ever bought on coding. If I were you try another writter.



3. This is a very good book for learning PHP, and surprisingly, most of the examples work right out of the book as he's written them, which seems rare for a programming book these days. The projects that he has you complete are highly relevant to what you'd actually be doing with PHP, and that makes it even better.
   
   The only trouble I had with this book was that he sure packed a lot of information into each chapter, and he didn't use the sidebars as much as I would have hoped. It's easy enough to follow along with the examples the first time, but if you want to go back again and figure out how he programmed a small detail, you'll never find it unless you reread the whole chapter again. All it would have taken was a few little bullets here and there in the margins to point out some of the off-topic stuff that was going on in the examples, and the book would be much more functional as a reference. As it stands, I probably will have to get a whole new book for that purpose.
   
   Also, the support on this book is phenomenal. I missed a small detail in Chapter 6 that caused my script to fail, and when I posted on the book's message board, I had a reply from the author in less than a day. That's a really cool added bonus.



4. I am a frontpage user that has set up static pages in a web site. I needed to move from static pages to dynamic pages using a database. I couldn't use PHP with FrontPage so I switched to Dreamweaver and needed a book that covered both dynamic pages and Dreamwaver. This book walked me through setting up the environment to have Dreamweaver work with Apache, PHP, MySQL and phpMyAdmin. I am completely non-technical so these areas were beyond my comfort zone but the book walked me through it very successfully. It then took me through CSS styles, setting up an online feedback form, setting up my first database and tying it into Dreamweaver. It also showed how to insert, delete and maintain records in order to keep the database up to date. This was an excellent book for a non-techie as it didn't take any knowledge for granted.



5. This book is written very clearly and is really easy to follow. I've learned a lot of other really useful stuff than just the PHP content, things that I now realise I should have been taught by the official Dreamweaver 8 book, but weren't. The PHP content for which I bought this book is fantastic - much better than another generic PHP/MySQL I have read, as this is tailored to the Dreamweaver 8 environment which takes a lot of the guessing out of the equation. This book is written by and for people who use Dreamweaver 8 in a practical situation. I'm still less than half way through my book and already feel like I've learned much more than I expected. Highly recommended. I'll be checking out Mr Powers' other books when I finish this one. Thanks David Powers, you're a genius!

5 comments about ANSI Common LISP (Prentice Hall Series in Artificial Intelligence).

1. Common Lisp is a bit of a throwback. And so is this book, from 95. There is absolutely no graphics described for Common Lisp here. Not unlike Fortran, C or C++. Here you get a "pure" language, without all that user interface fluff. The lack of an update to this book in 10 years also reflects the stability of Common Lisp. Veterans of C or Fortran should recognise this.
   
   The language itself will be radically different to many readers, if they hail from a typical C, C++ or Java background. Very flexible and powerful. Plus, the code can be nicely compact. In some qualitative sense, you might say that Lisp has more expressive power than many other languages, per some unit length of source code.
   
   The numerous problems should be appreciated by the diligent reader. And they should be tackled.



2. Once you move beyond the very basics of Lisp this is a great book to have around. It has nice to the point examples of how to perform common and uncommon tasks in Lisp. In the back of the book there is a small description of the commonly used functions for Lisp. The brievity and size of the book plus the density of the material presented makes for a excellent book to have at your side while you are coding. I wouldn't recommend it for developers or anyone who has never seen Lisp code before but once you are beyond that stage it is an excellent bargin



3. Paul Graham does a great job of reminding readers in practical ways that designing programs means examining trade-offs of performance, memory use, and simplicity. I appreciate any computer science book that not only introduces a language but also drives the reader toward developing a thought process that will make them implement great solutions in any programming language.



4. This is not an introduction to programming book. Instead it describes how an experienced programmer can use CL. As such, it is very dense. Descriptions of new operators are part of the text, rather than displayed in figures (there is a good reference at the back). This keeps the book small though.
   
   Perhaps the most profound ideas in the book are bottom up programming (modify the language to add the commands you need), coding at the highest-level possible until the problem is well understood, and that code comments have cost:
   
   "Good code, like good prose, comes from constant rewriting...Interlinear comments make programs stiff and diffuse, and so inhibit the evolution of what they describe"
   
   As for downsides, I found the exercises for each chapter to be uneven. One asks us to create a function that returns a copy of a queue, later we're asked to detect car-circular lists, yikes.



5. If you are interested in Lisp, you must get this book right after finishing Practical Common Lisp.

5 comments about C++ Pocket Reference.

1. For many years, I did most of my programming in C, but never learned C++. In recent years, I have been using Java mostly. Now I wish to get back to C++, and I have found this book to be an excellent introduction. In order to read this book one already needs to know how to work with the very low level aspects of C, and at the same time one must understand object oriented concepts. But for the reader who is at such a place, this book provides a very concise description of the C++ language. In just 125 small pages, the author manages to step through all of the aspects of the C++ language and concisely describe them.



2. If you are looking for a quick and dirty C++ pocket reference, this book should be on the top of your list. It covers all of the necessities, which is great for when you are switching between programming languages. If you have too many languages in your mind, a quick reference is a great little refresher, which this book certainly provides.
   
   My only qualm, and the reason it loses a star, is that the organization is not completely intuitive. However, after a few uses, you get used to this and it becomes a non-issue. I suppose you would have this with any book.



3. This book provides a quick and concise reference to the C++ language, covering everything from the basic structure of C++ files (including #include guards) and programs to variables and operators to the Object-Oriented features of the language. However, if you are looking for a detailed description of the C++ language, get The C++ Programming Language: Special Edition (3rd Edition) along with this book and you will have that plus a quick reference to almost all of the non-STL topics the other book talks about.
   
   On the down side, this book gives really superficial coverage of the STL, but then again this book isn't meant to be a pocket reference to the STL. For a good book on that, get a copy of The STL Pocket Reference.
   
   That being said, I would recommend this book to those who have either gone through or are going through their first year of programming courses.



4. This is a great C++ reference. After some years of mostly C and Java programming, I was able to review the language main points in a single day.
   
   It is a useful book for non-full-time C++ developers.



5. I have about a dozen of these pocket guides. I don't do C++ anymore but did many, many moons ago. My daughter is taking a C++ class now and I got this to help me remember C++ enough to help her with that class. It's all I need. In general, these pocket guides are enough for me most of the time regardless of the language or technology they are covering. Between them and google search, you can solve any programming task...

5 comments about Learning C# 2005: Get Started with C# 2.0 and .NET Programming (2nd Edition).

1. I've been programming computers for 30+ years and have migrated across several languages and systems as times dictated. I have accumulated courses, degrees, jobs, projects, and rows of books along the way. My most recent focus has been Perl on FreeBSD and Apache/CGI/mod_perl. I now have the need to write Windows GUI applications. Unfortunately, Microsoft has not chosen to make Perl a first-class language on their platform, so I am left with few choices (I am most familiar with ActiveState Perl and Cygwin). Given the fact that Visual C# 2005 EE is a free download, I've decided to climb two more learning curves -- C# and .NET.
   
   When learning Perl, I found O'Reilly's "Learning Perl" and "Programming Perl" books to be awesome. So, I bought the C# parallels, hoping for a similar experience. Unfortunately, this has not been the case.
   
   The content of "Learning C#" is basically a subset of "Programming C#" by Jesse Liberty with advanced topics removed. Both are what I would call language survey/ "gee whiz" books -- they describe the "what" and/or "how", but often leave out the "why". I forced my way through both and may use "Programming C#" as a reference, but "Learning C#" will only collect dust.
   
   This book also fails its presumed purpose -- teaching the reader how to write good programs in C# at a basic to intermediate level. Mr. Liberty is clearly an intelligent person and a capable programmer, but, unfortunately, he and/or Mr. MacDonald are not good teachers (or, at least not for how my brain is wired).
   
   Both books suffer from a deeper criticism that seems to plague almost all Microsoft subject books. I cut my teeth on Kernighan, Richie, Pike, Rochkind, Plauger, Bach, McKusick, Wall, Schwarz, Christiansen, etc., and those are the standards by which I judge all others. The writing style and technical accuracy of those authors are levels above what I find from most Microsoft subject authors. My guess is that the C/Unix and Perl authors train to higher standards (e.g. Ph.D, post doctorate), their vocations require them to write to higher standards (e.g. academic and professional journals, peer review), and they have experience in education. In Mr. Liberty's defense, those authors are not subject to scope and speed of the Microsoft product treadmill.
   
   Given the lack of a good technical bookstore in my area, I am relegated to reading reviews such as this on the Internet, ordering a book sight unseen, and hoping for the best. Please post your reviews so we can help each other. :-)



2. This is a tough book to review because it addresses very remedial concepts in the C# language, as if being directed at new comers to the language, but the authors address these topics at a very high level, as if conversing with computer scientists. I believe this book will only appeal to the type of newcomer who's willing to wade thru the murky waters of remedial language theory; one who's not anxious to plunge into the deep end of quickly writing your own programs.
   I am a business owner who programs fairly in depth VBA programs for use in my own company, mostly in MS Access. I've studied Python and programmed some console applications, as well as remedial programs in wxPython. I have some anecdotal knowledge of ASP.net, Actionscript and some other tools. My goal is to write my Access applications with a more robust toolset (enter C#). So I'm plagued with an ambivolence of wanting to learn from the ground up but finding overly remedial or theoretical examples mind-numbing and inapplicable.
   I think this book falls into that category: too theoretical and remedial, even for newbies. I'm striking immediate paydirt with the O'Rielly book C# 3.0 in a Nutshell by Albahari. This book is also based on the newer version of C#. Albahari's book is very dense and terse, which for me is good--it doesn't dwell on concepts but gives you strictly the meat and bone with a spartan example. Allowing you to immediately grasp the fact and move on. Liberty's book (C#2005) dwells on and on with a topic and frequently spends a great deal of energy on topics of very low importance--Arrays are given an entire chapter (though not addressed until Chapter 10, half way thru the book). Yet arrays are, even by the authors' admission, the "least flexible of the five standard collection" objects. But the other 4 get short shrift in the 14th chapter on Generics.
   Don't get me wrong, I think it's a good book. I'm just not sure how to use it, since I'm not going to get a CS degree and I will never write a console application (which is virtually the only kind in this book). I couldn't easily understand the examples given for class inheritance, though I came to the book with a clear understanding of it. On the other hand, the Albahari book had clear and concise examples by page 14.
   Again, I'm not trying to knock the Liberty book. Only trying to give my experience of it, for those who might describe their programming experience or focus as I do: I'm not truly a newbie; I undertand OOPs and have some skill with other, albeit simpler, languages; I want to program specific applications now; I have a limited tolerance for long theoretical explorations on the language. If you're like me, you might find more lean-meat in C# 3.0 in a Nutshell by Albahari.



3. This was the first book on learning C# 2.0, and while at first I enjoyed the book, when the author started discussing more advanced topics like delegates and events, his examples, I felt, were overly complicated and often left me agitated trying to figure out why he programmed the examples the way he did. After reading other C# 2.0 books, I realized just how bloated the author's examples were. Anyone interested in a beginner C# 2.0 book should try Herbert Schildt's book, The Complete C# 2.0 Reference. His examples are concise, performing as much as necessary to convey the topic Mr. Schildt is currently discussing.
   
   I felt it necessary to write this review after encountering many instances online and in print of people suggesting this title, and my adivce to someone about to purchase this book is to shop around. There are better alternatives than this mediocre book. I especially encourage you to look at Schildt's book if you are new to C#. Charles Petzold even has a free C# 2.0 book (pfd) on his website that does a decent job explaining the .NET framework.



4. This is an excellent book on C#. I use it as a reference all the time for my ASP.NET dev. It's almost as big as the Learning C# book by the same author.



5. I've read the high reviews for this book that's why I bought one, but eventually got disappointed with the lack of depth on explanations esp.regarding OOP. I suggest that beginners get a different learning reference. Jeffrey Suddeth's book is compact yet organized and topics are well-explained, but you must supplement that with other books as well.My experience is, you won't learn so many things in just one book, you need 2 or 3 while learning. I have yet to review Andrew Troelsen's book which is forthcoming. If you happen to find one that explains in detail the important topics like generics, collections, events and delegates and OOP, please help others by posting your review. Thanks

2 comments about Building Java Programs: A Back to Basics Approach.

1. The dominant approach to teaching Java is to start with objects as early as possible - the object first approach. If this is what you want, then this is not the right book. However, I believe that a growing number of people, myself included, have come to believe that object first doesn't work. Since OO is primarily a design and organization approach for building large systems it typically does not make sense to students trying to do one or two page introductory projects. In addition, the time taken in trying to explain objects comes out of time that would have been spent in learning programming basics such as loops, arrays, etc. The result is too many students that can't write good procedural code, as well as never grasping object.
   
   Due to this problem, I have chosen to organize my classes to begin with a procedural style of programming (focused on loops and arrays) and introduce OO at the beginning of the second semester. One of my frustrations has been a lack of supporting material for this approach, particularly among introductory Java textbooks.
   
   This book solves this problem for me. It introduces concepts in almost exactly the order I have decided to use in my courses. The book is well written. It has a modern organization in terms of things like sidebars and its graphic design without going overboard and trying to compete with MTV the way the Head First series does, or by putting in a bunch of expensive color pictures that have nothing to do with the subject as many current textbooks do. In short, the book design matches its subtitle of being "a back to basics approach".
   
   The authors have chosen to avoid showing a specific IDE and limit graphics to an optional chapter. I approve of both of these choices. I find that teaching IDE's, such as BlueJ, leave students confused about what the tool does and what the programming language does. While full IDE's, such as Eclipse, overwhelm first semester students. Graphics are "sexy" but every library is different. Real world libraries, like Swing, are too complicated for first semester students. Teaching libraries make the students learn something that is promptly thrown away. I, like the authors, would rather put the effort into the basics of programming.
   
   This brings us to the book's other strengths - well thought out examples and assignments that use the basic portion of the language (and could be used with practically any language). A series of character graphic examples are presented that do a good job of showing ideas such as repetition, and functional decomposition. They also include many good "case studies" that show how to apply the techniques introduced in the chapter to a "large" (for first semester) programming problem that is related to real world concepts. For example, one early case study calculates body mass index (fat to weight ratio) of a person. Their case study examples are definitely better then what I am usually able to come up with on the fly, which I think is a key reason to even bother with a text book.
   
   Summary: I believe this book delivers on its title. It is a well written book that focuses on the basics of learning a programming language without getting lost among "hot" topics like OO, IDE's, or GUI's. I will be switching my classes to this book.



2. One of the best introductory computer science books I have read. Very understandable and easy to read.

5 comments about Core Java(TM) 2, Volume I--Fundamentals (7th Edition) (Core Series) (Core Series).

1. I have an earlier version of this book and would love to get a Kindle version for reference. But... You save $3 by getting the digital version despite the fact that there is no shipping, storage, or printing costs?
   
   WTF?
   
   At $10 a piece I'd love to fill a Kindle with dozens of coding reference books that are filling up my library, but at $30+ a piece it's just not worth it.



2. I only wish the authors would have understood that it's better to write variables and declarations first and then use them later in the code. All the code examples are funnily written with the use of the variables first only to wonder from where they come from and later to realize that they're are at the end!!!!
   
   Also author has tried to pack too much of details which can be halved.
   Herbert schildt is a better option.
   
   But still the books is readable for beginners.



3. I have an older version of this book but it covers many of the core features of the language. This is a good book if you are looking to start
   programming in Java.



4. This is my favorite Java book. Although I have a background programming in C++, I find many of the other Java books to be cryptic or assume you wish to develop for the web. This book is straightforward and easy to read. I especially found the comparisons between Java & C++ interspersed throughout the text to be helpful.



5. I read this book years ago (I guess that was the first edition). I am ordering a replacement copy today, even though I am no longer an active programmer, because it is so good. It is one of those rare textbooks that you can actually read from cover to cover, like a novel.

5 comments about Pattern-Oriented Software Architecture Volume 1: A System of Patterns.

1. This is an unusual book in the pattern genre. It presents a number of patterns, categorized by archtiectural level. That's just the first part of the book, though. The third of the book is about the process of using, relating, collecting, and distributing patterns.

   Only chapter 2 really addresses patterns for the strategic, architectural level of a software system. It does a very adequate job, using a variety of notations, examples, and analysis steps. This book is from 1996, so time has changed our view of some patterns. "Reflection," for example, has become pervasive in applications based on plugins and software components. It is also a fundamental API in the major langauges (Java and C#) released since this book was published - perhaps reflection should be downgraded to an "idiom". That's just nitpicking, though, since reflection is even more important now than when the book was written.

   For contrast, the authors present additional design patterns (including some from Gamma's book) for use at tactical design levels. They also discuss idioms patterns that typically involve just a few lines of code within on function. The contrast between the three different levels of implementation and design gives a useful discussion. The authors also present a weak chapter on "systems" or "langauges" of patterns The discussion is OK as far as it goes. The weakness is in what it omits. After reading this brief chapter, the programmer has very little practical information about choosing patterns from some library for some task. The poor programmer has no information at all about how to link patterns together, and that's a real stumbling block for beginning pattern users.

   The final section of the book is really sociology. It's about the pattern community, what that community is for, and how to be a working member. I find the discussion un-helpful, but I expect opinions to differ.

   Even today, this is a good second book (after Gamma's 'Design Patterns') on patterns and pattern usage. It lack the depth and precision of Gamma's book, and tends to add words without adding meaning. On the positive side, it's broader than Gamma's, and addresses a wider range of implementation levels.




2. First of all, you need to understand the patterns in the gang of four book before you attempt to read this one. They talk about them all over the place without explaining them. That's a warning, it didn't affect my review.
   
   The major thing I don't like about this book is the abstractness with which they talk. They give you a high level description of a pattern and leave you with that fogginess.
   
   I think the examples were poorly chosen. I would have prefered to have examples that are only as complicated as they needed to be. Unfortunately the book uses examples like, "We're going to make a voice recognition application" or "We're going to make an OS that can run applications that were built on Unix or WinNT or Linux". I think the intent was to have some real-world-I've-been-working-for-six-years examples... it would have been smarter to put the real world examples in a separate chapter and keep the design pattern explanations simple.
   
   Also, I hate the diagrams. They should have just copied the diagrams in the GoF book! Instead they chose these diagrams that give less info and IMO are downright ambiguous in some situations. Another thing the GoF book does is have 2 separate diagrams, one that's a (simple) real world example and another that's a diagram of the actual pattern. This book only has the diagram of the actual pattern.
   
   I disagree with those that say this book is better than the GoF book. I think what they like is the material covered. Material aside, the GoF book presents the information in a much clearer way. That's why I prefer the GoF book over this one.



3. Second best isn't bad when the #1 book changed forever the way software architecture is talked about. GoF is not only well-written, but it covers all the basic, most-used patterns. Everybody thereafter is going to have to either re-hash GoF, criticize it, or come up with new patterns which are not as fundamental.
   
   This book is full of new patterns, and fortunately they are good ones: Command, Broker, Layers and worth the price of the book in itself Presentation-Abstraction-Controller.
   
   PAC can be seen as a generalization and extension of Model/View/Controller. The Abstraction is the domain-specific part of the architecture, effectively the Model. The Presentation exposes the Model in some interesting way, either as a user-interface in which case it is a View, or as an API, in which case the Presentation becomes a new Abstraction used by the next level up. The Controller is left with the job of coordinating the Presentation and the Model. The key to the pattern is that PAC agents can be built up into layers with the Presentation API of each lower agent creating a higher abstraction for the next level. Thus PAC becomes MVC for all or your architecture, not just the UI.
   
   The book goes into this at length and adds useful discussion of MVC. Highly recommended.



4. A lot of the reviewers have said that this is the #2 best book about patterns : just trust them. I have bought it with the hope to learn more about patterns, finally it has given me a larger point of view about the subject and has improved a lot my creativity during software designing processes.
   
   If your new to patterns just read the GoF, then buy this one. I think you will then have a nice knowledge about the subject.



5. This book uses an easy way to explain system patterns. I think every software developer has to read this book; it's a nice reference to help software architects doing a well-done job. Another great reference that you may have in your list of references is the classical book "Design Pattern", also at Amazon.com.