5 comments about Compilers: Principles, Techniques, and Tools (2nd Edition).

1. The CGI cover looks great! I only wish it stretched along the spine of the book like in the previous editions.



2. I spent some serious quality time with the first edition (the "red dragon book"), in three main episodes over the past dozen years: 1) undergraduate compilers class, 2) industry project, and 3) parser generator implementation. During all three episodes, I was disappointed in various ways, though there is no denying that the book contains a wealth of information. As an undergraduate, I found the book somewhat impenetrable. When in industry, I found the book too abstract. When implementing a parser generator, I discovered that the book excludes important research results with regard to LR parser generation. It is the last disappointment that I will focus on.
   
   The book presents parser generation in layers of increasing complexity, from SLR to LR to LALR, where LALR is presented as the penultimate algorithm, though LALR parsers can only handle a subset of the grammars that LR can handle. The justification for this is that the original Knuth LR algorithm is intractable for large grammars. However, an efficient, fully correct, approach for LR parser generation was published in 1977, and on top of that it appears easier to implement than efficient LALR parser generation! The red dragon book's original authors simply cannot have been unaware of this research result, but I suspect that they elected to warm over the "green dragon book" (published in 1977) rather than incorporate the state of the art as of 1986 into the "red dragon book". Now here we are another 20 years later, and as near as I can tell from reading through available online information, the "purple dragon book" is perpetuating this omission. The result of the red dragon book is that we have an entire generation of computer scientists who have been mislead to think that LALR is somehow superior to LR, and the purple dragon book is setting things up for yet another generation to be mislead.



3. This is the classical reference book for compiler design. This is not an easy text because of its heavy use of mathematical notation and the algorithms are presented only in pseudo code but you will not find a more complete collection of compiler related algorithms than in this book.



4. The Dragon book is a core text for understand complier theory. Great technical reading for all software developers and software engineers.



5. This book is famous, and when I told people 20 years my senior that I was in compilers and I was using the dragon book, they knew the book. There are probably some changes between editions between now and then, but the fundamentals of compiler design has changed little.
   
   And when it comes to be basics, reading this book can be more like slogging. The information is there, but it isn't quiet clear. Some topics have examples that do most of the explaining, while other topics lack a nice example that would explain it.

5 comments about Fast Track to MDX.

1. I was already quite familiar with SQL and I bought this book to understand what MDX was about. I was sorely disappointed.
   
   If you are suspicious of books that are full of half a page screen shots of navigating menus and changing settings, your suspicions would be well-founded in this case. I daresay 40% of the book consists of screen shots most of which could easily have been replaced by single sentence descriptions (or half sentence ones.)
   
   If you raise your eyebrows seeing a 'chapter' titled "Server side color coding" whose whole *eight* pages collapse to four when excluding screen shots, then this book is not for you. No wonder that, despite being close to three hundred pages long, the book is an extremely quick read.
   
   There's a lot of fluff, like frequent quotes (yes, in italics, separated from the text with whitespace) from the authors (I guess, because they are rarely attributed), spread around like pearls of wisdom pointing out the blinding obvious. I did not know that quoting from yourself (unless you are Einstein) was good writing. Actually, why not remove the quotes and just get on with?
   
   There is very little formal introduction to concepts, for example, the syntax of MDX queries is never discussed. I guess you are supposed to derive it from looking at examples. Needless to say, the book is as far from comprehensive as it is humanly possible.
   
   All in all, I did not find this book a useful introduction to MDX. I will have to find a better book for that.



2. Very good book...Helps a lot to understand OLAP and MDX concepts...Would like to see new edition with more advanced chapters



3. Great introductory book on MDX.
   MDX Solutions (the other one) is definitely more advanced.
   I would like to see a newer edition of "Fast Track" with AS2005 in mind.
   Of course by then, AS2008 would be RTM.



4. It's a good book. Just the data cubes are very old. I had to convert them to 2005 format.



5. This book appears at first read to be a winner. But one soon finds out that it is not all as easy as it appears. First and foremost, the included CD provides what appears to be a great selection of sample files, and great exercises that test your learning and knowledge of MDX; to use this software you need Microsoft SQL Server 2000. If you don't have this ancient piece of software accessible on a network, or loaded onto your own laptop, you will not be able to use the CD. Despite a new `Second edition' released in 2006, when SQL Server 2005 was available, the authors did not see fit to update the included CD to use this more easily available software.
   
   I eventually was able to locate and load SQL Server 2000 Analysis Services, and then load the necessary SP3; only then did the included Proclarity Software work.
   
   In the end, it turned out to be a great learning exercise. I did learn a lot about MDX, about MS SQL, and Analysis Services, an unexpected Bonus.

2 comments about WPF Recipes in C# 2008: A Problem-Solution Approach (Recipes: A Problem-solution Approach).

1. This very well written and organized book provides comprehensive coverage of WPF features. The authors get down to business right away, assuming that most readers already know basic WPF concepts such as Dependency Property, Attached Property, etc. because they don't waste time explaining many such building block concepts, and yet a few of the recipes are surprisingly beginner-ish material. Of the 200+ recipes, the ones that I thought gave me the most bang for my buck are those contained in Chapters 11 (Creating Animation), 7 (Working With Test, Documents, and Printing), 4 (Creating Use and Custom Controls) and 5 (Data Binding), either because they covered materials not found many where else, or they clarified some concepts for me. For example, the Animation Recipes discussed concepts not even covered in the very well-received "Practical WPF Graphics Programming" book by Jack Xu. The recipes in Chapters 6 (Working With Styles, Templates, Skins and Themes), 8 (Multithreading), and 10 are good, and the remaining recipes in Chapters 1 (Building and Debugging WPF Applications), 2 (Working With Windows, Forms, and Layout Management), 3 (Using Standard Controls), 9 (Working With 2D Graphics), 12 (Dealing With Multimedia and User Input) and 13 (Migrating and Windows Forms Interoperability) cover materials easily found in other books. Another positive, however, is that some chapters contain bonus nuggets of information on things you can do to make your code play nicer with designer tools like Expression Blend. Overall, I think the authors did a great job!



2. This book has what is very hard to find with such new material as WPF... good working examples. I truely believe the the chapter on user and owner controls more than pays for the book, although the book offers much more.
   Apress rates this book Beginner-Intermediate. For me, I don't think I could have understood this book 6 months ago, but after working with WPF for about a year now I find it extremely easy to read and very informative.
   
   I found direct answers to problems that I have had over my last 6 week project, and know that if this book was out last month I could have cut 2 weeks out of that project with ease.
   
   Back to user controls (again, this is not the only good about the book... it just what I'm focusing on right now). The chapter offers not only good examples, but insight from the authors on how to make your new control work well with others that would want to restyle it. Another section shows you how to know if your in delevopment mode so as to change it's look when in Blend if required. All in all a pretty thourgh coverage.
   
   One thing I'd like to say, as I think this might bug some people. There is a fair amount of duplicate code in the book, as there are times that the same code really does express more than one idea, and can be reused in other sections (or even the same section at times.)
   
   I actually agree with the author's desision to duplicate the code instead of referencing me to other sections in the book. I can keep my train of thought where it should be, and don't have to keep flipping back a few chapters as in some other books. Even with the dupicate code, there are other functions added if appropriate.
   
   Of the examples I have read, I find them to be concise, and to accurately portray the idea the authors are describing. They do not attempt to be more than they need to be, but are strong enough to cover more than the bare minimium.
   
   Congratulations on a job well done.

5 comments about wxPython in Action.

1. Simply awesome. Awesome cubed:
   
   (i) wxWidgets is a wonderful thing - a cross-platform windowing
   toolkit that uses native widgets to give extremely pretty
   cross-platform GUI applications.
   
   (ii) wxPython is a fabulous implementation of wxWidgets in Python,
   taking advantage of various Python fabulousities to make using
   wxWidgets much easier than in C++. (If you do any programming
   but you've never heard of Python run, don't walk, to
   [..].)
   
   (iii) The book is an excellent introduction to wxPython. I
   had a little emergency, caused by the fact that my PC had
   died and my Delphi programs didn't seem to work on the MAC
   I was migrating to. Starting with no knowledge of wxPython
   (but with some familiarity with Python) in one three-day
   weekend I was able to write a rudimentary spreadsheet application -
   at the end of those three days it already worked better than
   the Delphi application it was replacing (just because writing
   Python is so easy I added a few features that I'd never got
   around to adding to the Delphi version).
   
   If you've been looking for something that does this sort of
   thing then wxPython is what you want, and you want this book
   to go with it.
   
   (If you're a Python person who's been using tkinter: wxWidgets
   is not much harder, it includes _much_ more builtin functionality,
   and it gives _much_ nicer results, since it uses native widgets.)
   
   David C. Ullrich



2. I bought this book when I needed to write a wxpython app at work. I'd done a lot of programming in python before, but had very little experience writing gui apps and non using wx. This book got me up and running very quickly and I was using wxpython productivly almost imidiatly. This book gives a solid introduction to the basics on wxpython and how to test and develop wxpython apps.
   
   However the book doesn't cover a lot of more advanced or complex topics. If you need to to anything that isn't the most common and obvious approach you'll be on your own. I quite quickly found myself running into problems that wheren't covered in this book.
   
   So on the whole this is a great book for quickly getting you up and running, and will have you writing simple wxpython apps in no time. However for anything more complicated you need to consult other sources.
   An Advanced WxPython in Action book would be most welcome.



3. This book is hard to use as a reference but it is better than nothing.



4. Before I picked up this book I knew nothing about GUI programming, but a good bit about Python. This book let me jump right into writing useful GUI's. Typical programming text books build on concepts sequentially, which is great for classrooms but not for learning on the fly. This book just jumps right into applications and teaches through examples. I was so impressed by this method that I plan on buying more books from the in action series whenever I need to learn another programming language. This book has been my #2 resource right behind Google, which is saying a lot.



5. If you have been searching for wxPython books, you may notice that this is about it. And if you buy it you may wish there were others to choose from. I think the book is solid in foundation material but it is not very well organized. I like to be able to skim through a programming book, get ideas of functionality that are useful to my work, and then proceed with my work, turning back to the book for occasional reference, clarification, or a little more insight into advanced techniques, which typically helps with refactoring.
   
   This book almost forces you to go through its code base, which is rather sparse and tied into much narrative (perhaps too much for a programming book). Maybe some people have a different learning approach, but I would prefer to get my hands dirty immediately and shoot off on a thousand experiments of "what if I changed this, tweaked that, used it in this way or that way." That is how I learn to code in a new environment; then back to some narrative and examples to perhaps explain why it works that way if not obvious.
   
   That is how I find much of wxPython in general, not obvious. On the other hand, it seems about the best current solution for doing GUI with python. PyQt4 is amuck with the whole licensing issue and basically treats python users like second-class add-ons. No thanks. And quite frankly most of the other GUI development environment I have tinkered with just seem to fail in comparison.
   
   So, if you are interested in wxPyhton, and don't find the online documentation that complete, then this it. There is a PDF version that I ended up getting from the publisher, not sure if Amazon offers it, but given that I will likely be tied to the book and the IDE for a while to get acquainted, I would consider this route if you find yourself in a similar learning mode/environment.

5 comments about Managing Projects with GNU Make (Nutshell Handbooks).

1. This book is a good place to start for learning how to manage large projects with GNU Make. It covers the basics and then moves on to specialized topics including writing portable makefiles, increasing makefile performance, and debugging makefiles. I've been using GNU Make for years and still found the book worth reading.



2. I've just begun reading the book and it's a nice book on GNU's make. As already mentioned, it is not a handbook but rather more like a discussion of how to best use make in your builds. That said, I'd like to point out that the text is available on the net for free. If you look at the associated O'Reilly web-page for this book, you can find the link entitled "Online Book" - click on that to see the index of the free, online book.



3. Make has been an icon in the GNU / Linux world for over thirty years now, and continues to be one of the most used utilities to ever be released on the platform. A good number of other projects have risen to take its place as an automated-build utility, but as of yet, none have been able to unseat Make. Some see Make as being too arcane and finicky to survive in the once it is confronted with an advanced, user-friendly, utility of the same purpose. However, as it stands now, Make is still the standard in the `industry', and Makefiles are distributed with almost every major software package on the GNU / Linux platforms (as well as some others!).
   
   Any avid Linux or UNIX power user, as well as most system administrators, will need to have some knowledge of Make to do what they need. Programmers, on the other hand, need to have an intimate knowledge of Make, Makefiles, and what the abilities of Make are. This book is more for the latter group, and goes into detail that the former group probably doesn't need to know too much about. For the former group, I would suggest a more concise, simplified version of this book. For the programmers, this book is a must-have.
   
   As I mentioned before, Make can be a little finicky at some points. This, some may say, is an understatement. There are a number of "gotcha's" in the language, as well as a lot of `hackish' features (when I say `hackish', think Perl `hackish'). Perhaps, more importantly, however, there are a lot of fairly advanced features that Make can handle, and few people seem to use these. This is where the book really shines - it goes over the rarely-seen, but perhaps some of the most advanced features, of the Make utility.
   
   This might seem obvious to most, but the novel assumes that the reader has previous programming experience, and throws C++ code blocks at the reader on the third page of the first chapter. If you don't have any programming experience, you probably shouldn't be reading this book anyways - but I thought it worth mentioning.
   
   The primary content of the book is split into two sections - basic topics, and then the more advanced topics. The author does an excellent job of starting out with the absolute basics, and slowly progressing into the more advanced topics at an easy-to-follow pace. I never felt like the pace was too fast, and the author does an excellent job of giving examples for each of the topics that require one. Each example is explained in detail, with an added bonus of a few "what-ifs" at some points.
   
   In fact, this leads into one of my few complaints with the book. There is so much code, and so much text, and... well... nothing else. There are maybe a dozen and a half pages in the book that aren't just one big solid block of text. After a while, it becomes hard to take. It doesn't help that each page looks almost exactly the same, so after a while, things start to kind of bleed together. In the next edition, it would be nice to maybe see some page styling, new layouts, some more images / tables where possible, maybe some funny side anecdotes or something - *anything* to give the text some life.
   
   Once you accept the pedantry of the text, you will find that it is extremely well written, and easy to understand. There were very few instances in which I had to re-read something multiple times to get an understanding of what was being communicated, and the author's ability to describe even complex topics in simple terms is really impressive at some points.
   
   The advanced sections of the book delve into some topics that I didn't expect to see, and was honestly pleasantly surprised that they made their way into the text. Included in the list of `surprise topics' are alternatives to Make, benchmarking Make, parallel Make, distributed Make, third-party programs that work with Make to add new functionality, and even sections on Cygwin and Make.
   
   Also in the advanced partition of the book were two other sections that I found to be extremely helpful, if not essential: Debugging Makefiles, and Example Makefiles. The Example Makefiles chapter includes both excellent Makefile examples as well as discussion of what is happening in them. The Debugging Makefiles chapter goes over a lot of the "gotcha's" in the language, how to find a problem, and then possible fixes for it. These were both nice touches to the book, and are examples of the dedication the author shows to covering the more difficult parts of the language.
   
   For the purposes of an in-depth, complete tutorial in Make, this book succeeds wonderfully. The author, although a little pedantic in the design and layout, does an excellent job of communicating each lesson. I recommend this book to any professional or hobbies programmer looking to get a little extra control over the build process.



4. Mr. Mecklernburg is definitely an expert in GNU Make and the book shows it. The information it contains is well organized and the author doesn't spend precious time on non-essentials.
   
   The downsize of the book consists in the total lack of fun it produces. The reader has no joy while learning about make and he may quickly find himself yawning at pages and pages of explanations with little or no examples that smooth out the learning curve.
   
   The book seems as if the author tried to show off his knowledge with the best eficiency per page and in the smallest number of pages. He succeeded, at least with me: I am convinced that Mr. Mecklenburg is an excellent engineer but a terrible teacher.
   
   Besides the content not being enjoyable, it is so much biased towards *nix that the Windows programmer righfully asks himself "what about me"? The solution offered by Mr. Mecklenburg for Windows consists in the... Cygwin environment. I'll abstain from commenting on this suggested choice.
   
   Despite its drawbacks, the programmer may find enough material to learn from it and get the job done. But make no mistake: this is not a feat and you'll need quite some determination to finish this book and extract something useful out of it.



5. I've used make and makefiles for many years. In my current product development there was suddenly a need for a little more than the standard make knowledge. For most Open Source tools there is a good O'reilly book, so I grabbed this one from the store.
   
   This book exactly fitted to my need. It does what it should do, it explain make, and nothing more. Already after part 1 I got useful new bits of information. Nothing major, just small "ah-ha, that's how the do it"'s.
   
   The book is structured ok (I felt it could be structured better, but have no suggestion how). It consists of basic and advanced parts. The basic part will cover rules, variables, functions and commands. The advanced will talk about large project, C++, Java, examples and some debugging.
   
   All the basic concepts chapters were pretty good. Somehow I didn't enjoy the advanced chapters too much. I didn't feel I was learning much new things there. The Java chapter was a little odd. I've not met any Java developer who currently uses make, most have switched to ant quite some time ago (book was 2004, so might be changed in the fourth edition). The example makefile of the book was somehow not interesting. The second example makefile was the linux kernel. This was more interesting, but it didn't go into too much details.
   
   All in all, I found it a good book. It gave me exactly what I needed. Somehow the writing style was a little dry. I couldn't really point my finger on what made it so.
   
   I'll give it 3 stars. Not because it's not good, but exactly because it's a good book. However, it didn't give me something extra, which I always hope a book gives me.
   
   Recommended when needing to know more about Make :)

5 comments about Oracle PL/SQL For Dummies.

1. This book has a lot of good technical data, but it's not well organized for learning, more of a reference. Also, it assumes you are already an experienced SQL programmer.



2. I am very pleased w/ the purchase of the book. If your goal is to learn PL/SQL quickly and comprehensively, this is the book to buy. It covers all the fundamentals you need to know about PL/SQL and it is excellently written. I have been a developer for 20 years in many languages. Learning new languages from overly technical books and writters, I find, often times make your learning process slow and ineffective. I took this class at Oracle, but there were topics that the training manual and the instructor did not do a good job presenting. This book clarified many of the topics I that were presented in class in a simpler, clearer, and more effective manner. I highly recommend it.



3. Fantastic text for beginners in PL/SQL. Clearly laid out concepts and samples, and hints at naming conventions and other standards to be used. A very solid introduction to the language.



4. This is absolutely, hands-down, the worst computer-related book I've ever had the misfortune to read. It's also the first "For Dummies" book I've read, so it may be the fault of the series rather than the book.
   
   The book is poorly written and poorly edited. There are errors in the code examples and numerous inconsistencies in the text. The book doesn't really say anything except, to paraphrase, "There are many things that you should know, but they're beyond the scope of this book. Check somewhere else."
   
   I bought this book based on the recommendations on this page-- my mistake. I'll never buy a "For Dummies" book again.



5. Easily one of the best programming books I've ever bought, in my life. I can't tell you how many strange programming assignments I have been able to pull off because of this book. From cursors to clobs and whatnot. Everyone in the office thinks I'm a wizard because of this book. It is also a very good reference book with great examples anyone can pick up easily. I agree, with one of the reviewers, not really really a beginners book, but if you write PL/SQL for about 3 months this should be an indispensable resource.

5 comments about HTML Utopia: Designing Without Tables Using CSS.

1. I honestly didn't use CSS too much in the past and I always used tables for my layout. However, this book has quickly shown me everything I needed to know to become proficient and confident in using CSS; it has also allowed me to discontinue using tables (except for certain situations, i.e. tabular data). This book is a very easy read and a great reference to keep on your desk for all your CSS needs.



2. I'm not going to launch into a rhapsody like some reviewers do, pointlessly going beyond the pail dissecting a web design book like this. For me I just want to see if a book has what I need to get me where I need to go! Here's the facts - jack.
   
   - The title is misleading, you will learn to design without tables, however that's not where the book is focused, if you expect myriad examples of how to layout pages with CSS you will be disappointed (as I was).
   
   - Almost half of the book is reference!
   
   - It is well written and a good book for those with some (x)html experience looking to power up with CSS.
   
   - Is it worth the money? For me it wasn't since I want a book that's chock full of layout examples - however it's a good deal for those looking to learn CSS.
   Of course you can learn all of the stuff in this book online for free, there's many great CSS sites out there.
   
   So there you have it! A sucker free review with no superfluous wordage.



3. Its a great book, but doesn't push very far for creativity. Some books smash the information through to you in such a way like its picture book... extreme use of examples. I'm more of the "just give me the methods and information clearly, and lemme fiddle around with my own creativity." The entire book I was thinking to myself "how can I take these examples and convert them into actual web page designs I want to make?"
   
   Despite that, there is still a lot of information crammed into it. It has a beefy index, but then again, I wish it had more CSS "tricks." Like methods and ideas for pushing css possibilities to the extreme, despite minimal browser compatibility. It didn't shoot for the sky..



4. An Excellent and very informative book. Not only does it have a complete list of CSS 2.1 compliant listings, property by property , but practical use and examples that make it easy to understand and apply. You can't beat Amazon's price. I purchased this and "The CSS Anthology" for the same price as one of the books at BN or Borders. AN Excellent Addition to the Web Programmers Library!



5. Owners of the book can download a zip file. The zip file contains all the examples, which there are few. You only get 3 examples in the first 6 chapters. I don't really want to read and read and read, I want to practice. The examples in the remaining chapters mostly build on a site adding headers, columns, and footers. I'm not sure I'll get that far, I prefer to learn by doing, not by reading. Here is the breakdown:
   
   Chapter 1 -- 1 example
   Chapter 2 -- No examples
   Chapter 3 -- No examples
   Chapter 4 -- No examples
   Chapter 5 -- 2 examples
   Chapter 6 -- No examples
   Chapter 7 -- 6 examples
   Chapter 8 -- 8 examples
   Chapter 9 -- 4 examples
   Chapter 10 -- 7 examples
   
   In all fairness, the reading chapters do teach a lot, and give the foundation for the practice parts that come later.
   
   I don't know if I will keep the book. The price point is fair but I'm having trouble following along without seeing any examples..

5 comments about Java Software Solutions: Foundations of Program Design (6th Edition).

1. There is an updated printing of this book that uses ISBN 0-321-32202-7. The updated printing (which corrects small but important changes from the final version of Java 5) also is called the 4th edition. The publisher added words "Java 5.0 Version" to the title listed in online stores, and added a leaf with the words "Covers Java 5.0" to the bottom right of the cover. Be sure to verify that you get this ISBN, and do not to buy an old printing that you can't return.
   
   This URL to purchase the most up-to-date printing from Amazon is: http://www.amazon.com/exec/obidos/tg/detail/-/0321322037/qid=1126549578/sr=8-2/ref=sr_8_xs_ap_i2_xgl14/102-3991796-1688157?v=glance&s=books&n=507846



2. Lewis & Loftus give the reader an excellent introduction to object oriented programming in Java. The very clear explanations as well as simple examples do an excellent job demonstrating many concepts to the reader. I recommend this book to anyone wishing to learn Java for the first time.



3. Another great hit by Codemate. Best programming book for new programmers/students. Really goes step by step and gives adaquete information for newbies.



4. For the price I wouldn't buy this book unless it was a textbook for a class or if you can find one used. That said, it is a great book for someone with a few Java basics under their belt. You could use it as your first Java book if you are a quick computer learner and can remain focused as the chapters are rather long and meaty. Each ends with a GUI section which could almost be a chapter on its own. The code runs well and is available for download. There are very few mistakes and/or jumping assumptions in Java learning although the complexity makes having an instructor to ask questions helpful. Basically it is a textbook for just after intro object programming college class and it does that very well.



5. In case you're doubting how much of a beginner's book this is, consider that the first chapter of this book is all about telling you what a computer is. If you have any experience writing any sort of script or program you will not want this book. If, like for me, it's required for a course, keep an eye on the bookstore's textbook buyback schedule.
   
   Even once you have learned what's taught in this book, you will probably find it frustrating if you try to use it as a reference for Java syntax. Information about the language is dribbled out in bits and pieces with no clear way to find what you're looking for. Well, yes, there's a table of contents and an index, but you'll do better selling this book back and picking up Java In A Nutshell, 5th Edition once you have some familiarity with Java.

1 comments about Memory Dump Analysis Anthology, Volume 1.

1. As an Escalation Engineer for a large software company, live debugging and post-mortem memory dump analysis is a part of my daily routine. I often find myself debugging some strange/unique problems, where I am sometimes stuck staring at stacktraces wondering where do I go next... In these times I would often find myself searching the web, trying to find more information, which would mostly leadme to http://www.dumpanalysis.org... On this site, I usually find that Dmitry not only encountered a similar situation before, but has fully documented and classified in-depth debugging information regarding the issue.
   
   It is no surprise that the contents of his book (Memory Dump Analysis Anthology, Volume 1) contained a vast collection of Windows debugging knowledge, fully illustrated, with great explanations of complex topics broken down nicely so that even a beginner can hit the ground running with Windows debugging. This book is a great resource for both beginners wanting to explore the realm of Windows debugging, as well as for professionals who perform debugging (both live and post-mortem) that need a reference for various memory patterns.
   
   In the past it has always been difficult to find a solid source for Windows debugging information, as bits and pieces of this knowledge has been scattered across various sources. It is nice to be able to pick up one resource such as this book, and follow it through to the end and actually build a strong Windows debugging foundation. Complete with code examples, illustrations and screenshots, this is a must have for anyone who is serious about debugging on Windows.
   
   Cheers!
   KappA

5 comments about Wikipatterns.

1. I'm disappointed. This book lacked the substance and depth that I expected. I was very excited to receive it, as I've been looking for a good book that details the hows and whys of the wiki, but I looked through it once and haven't picked it up since. Its geared toward business use and the different kinds of users one will encounter when trying to set up an internal business wiki, but it doesn't get as much into the hows as would like, beyond surface ideas of how to encourage participation.
   
   A much more challenging book would be a discussion of those things in regard to public wikis -- it's a very different scenario when someone at work has to use the company wiki, versus an internet user who does so for pleasure or fun.
   
   Also, the production run is shoddy -- the paper inside the book is very thin, the print half-tones are extremely rough and the cover is of poor quality.



2. I thought this was a great book for understanding the power of Web 2.0 and use of Wiki's



3. Don't bother buying this one; a minute skimming in the book store is all you need to extract what little content there is here. This book is just a collection of too-long generalities and opinions that don't add up to much. I worry that anyone who finds this book useful could have responsibility for setting up a wiki.



4. Wikipatterns is a good book, but not a great one. It did help me clarify a lot of my doubt regarding the wiki technology and the book has a lot of case studies.
   There are many patterns discussed in the book and also on the website. Choosing the right pattern would still be complicated task even after reading this book.



5. It's far from an exciting book (it was great for helping me fall asleep at night), but it has valuable content. You can actually get the whole book online, since it was, naturally, written on a wiki -- in fact, you can contribute to the wiki. I recommend the website/wiki as a resource for all of involved with community management and wikis: [...]