No comments about RailsSpace: Building a Social Networking Website with Ruby on Rails (Addison-Wesley Professional Ruby Series).

5 comments about Cost-Based Oracle Fundamentals (Expert's Voice in Oracle).

1. This is the book that one definitely needs to read (and understand) in order to get an idea what the CBO is all about.
   
   Jonathan's examples and presentation is excellent. Though the topic is quite intense, the book is quite pleasant to read. This book is a worthy follow up the classic "Practical Oracle8i".
   
   As regards the usefulness of the book in real world scenarios, I can only say that if one wants to approach SQL tuning as a science, one needs to learn the CBO, and this book is essential.
   
   This is volume 1 or 3. I will definitely be eagerly waiting for the next volumes.



2. This book gets a prized spot on my technical shelf. It is a challenging read, and has taken the most time of any book I have to get through, but it is quite good. The optimizer is such a core part of what makes Oracle worth the investment, that any DBA who does not understand it is doing a disservice to the company investing such capital into the product.
   
   Lewis' use of proof through example is second to none, and leaves me feeling confident about the knowledge I've gained. His insights are not only theoretical, but quite applicable. I learned much about manipulating and using the DBMS_STATS package, about data model design and why data knowledge is so critical to the DBA.
   
   My nervousness about hints and about upgrades was reinforced with concrete examples that have improved my test plans, upgrade methodologies and overall made me a more competent DBA. I've directly used this knowledge to support my clients in better ways than I would have before it, and that is well worth the price of admission and the time to get through such an in-depth work.
   
   Thanks Jonathan!



3. Each quarter my team of DBA's has one book that we read and discuss in team meetings. This quarter, Cost-Based Oracle Fundamentals is it. This book is a wholly remarkable book for the moderate to advanced DBA. It is a deep dive into the Oracle optimizer, providing some wonderful insights into not only how it works, but why. It is not a book for the faint of hart, or those waiting breathlessly for retirement. It is a book for those who want to understand the CBO in more depth.
   
   Within the book, Jonathan provides insights into how the CBO *should* work. He follows up often by demonstrating the maturing (or devolving as the case may be) of the CBO from version to version. Beyond his own experimentation and results, he leads the reader into the process that he has followed to come to understand the internals of the CBO, providing a road map allowing the reader to continue to explore the optimizer in future releases.
   
   However, I must take Jonathan to task, for he is a nasty tease. This book was released about two years ago. In it, he leads us on with promises of forthcoming volumes 2 and 3, dangling the carrot out there for us to follow. Sadly, these volumes are yet to be seen. Jonathan! Quit running to and fro filling our heads with knowledge at various conferences and write those books man!
   
   A caution for the new DBA or the cursory SQL developer, you may find this book overwhelming at first glance. For the new or even intermediate DBA, it might be hard to derive practical application of what Jonathan is teaching at first glance. Take your time with the material and the insight that you will gain will be invaluable.
   
   Overall, if you want a book with meat, then this is the book for you. It will expand your mind and the way you look at the Oracle CBO.



4. It doesn't mean you won't love the book. I found it to be far too narrow and, even as an Oracle OCP, boringly written. That may say more about me than it does about Jonathin Lewis, who I know is brilliant and has written brilliant stuff before. I just didn't get as much out of it as I thought I would.



5. Jonathan Lewis has perfomed an invaluable service to the Oracle community. He doesn't just offer opinions of how the CBO makes decisions from his vast experience. He also offers the scripts he used to verify behavior of the Oracle CBO. This equips the user to replicate Jonathan's work with newer versions of oracle and adapt the scripts to your circumstances.
   
   Dennis Williams

5 comments about C++ Coding Standards: 101 Rules, Guidelines, and Best Practices (C++ In-Depth Series).

1. This book is a very readable reference book. The authors have read several books and condensed the best coding rules to prevent many errors. If you code in any language other than C++, read this book because many of the hints are useful. (If you code C++, then all of the hints apply.) And if you don't like rules and guidelines, then just read the "exception" section provided in each entry to be sure that your code meets the exception.



2. It's Sutter! It's Alexandrescu! It's both of them together! And the dark lords of C++ have combined forces to produce... er, some coding standards.
   
   Yes, another book of best practices. Some readers may therefore be a tad disappointed that the combined fruits of the authors' labours will not be shattering their puny human minds with the sort of C++ that cause lesser compilers to accidentally create black holes that destroy the entire universe.
   
   But let's evaluate the book on what it sets out to do, which is to give 100 bite-sized pieces of advice on C++ coding. And it's very good. You might prefer to see it as an annotated guide to the state of the art in intermediate C++ programming, in particular to Sutter's Exceptional C++ trilogy, which has become sufficiently sprawling that a reorganisation of the material, plus pointers to which book said what, has become quite welcome.
   
   Yes, it's true that C++ is hardly short of books telling you when to pass by value. But take a look at the bibliography - it's a synthesis of all those other tomes (the Effective series, Sutter's own Exceptional series of course, and older books like C++ Strategy and Tactics) plus magazine articles, into a neat and compact whole.
   
   Few of the items are longer than one or two pages. This is good because the advice stays simple, clear and direct. On the other hand, some of the items feel a bit squeezed into the available space, with discussion deferred to the books in the references, which is a little frustrating on occasion. After all, a lot of the best parts of the Exceptional C++ and Effective C++ series and their ilk is not so much what to do (or not to do), but the why behind it. There's plenty of the former, but not so much of the latter.
   
   If you've read any other coding convention books (like those in Steve McConnell's Code Complete) then the first quarter of the book may feel like the same old same old. And of course with there being exactly 100 items, some are more heavyweight than others. But there's definite C++ meat here, in particular with the items on Exceptions and the STL.
   
   C++ Coding Standards is as well-written as you'd expect from the authors - their friendly, slightly conversational writing styles mesh nicely and I couldn't tell who wrote which bits. And it's a great summary and unification of C++ best practices that someone just starting out could easily refer to in their initial forays. Perhaps even more experienced hands will discover a few tips, implications or issues that they hadn't considered before. It could also be a good way to ensure that a team are all up to date on best practices.
   
   Essential for those with a large C++ library? Probably not, but it does the job it sets out to do very well.



3. If you own the 3 "Exception C++" books, do not buy this book. It is just a mirror copy of those. And the explanation in this book is brief. Typically, if you are familiar with the content of this book, it works as a quick reference manual or pocket book.



4. I had high expectations about the fruit of the association of 2 authors that I appreciate but the result did not meet these expectations. Basically this book provides 101 rules or guidelines that you can get for free by looking at the table of content. Each of these rules is then followed by a very short explanation (1 or 2 pages usually). In my opinion, most of them are common wisdom that you can get from other sources. This is it. That is all you will get from this book. For that reason, I recommend to skip this one except if a convenient and compact collection of common knowledge is something that you are looking for.



5. I think this is one of the most useful C++ books one could have if working in a team. Most companies don't have a very large set of coding standards, and every now and then there will be a discussion about which is the best way to implement something. That is the time to when this book shines:
   
   1) You can show your co-workers the page for the related item, and the explanation for the underlying rationale will be so concise, they can read it while standing.
   2) Every item is backed with heavy references to standard works by the top names in C++.
   
   Basically it is a tool for effectively ending discussions in the most constructive way possible.
   
   It's the supreme index into the world of collected C++ knowledge.

3 comments about GWT in Practice.

1. GWT In Practice is an essential book for any web developer who works with or wants to work with the GWT toolkit. In addition to covering GWT fundamentals, the book really focuses on real world applications, not just Hello World type apps which are largely useless. The ample code samples throughout the book make applying GWT to solve something in your web application easy. I highly recommend this book.



2. GWT In Practice is well worth having as a reference for any developer who will be using GWT toolkit or is already using the GWT toolkit. The book makes for easy reading and not only covers the key areas of GWT but also the deployment and continuous integration of your GWT applications. The book's code samples are also very helpful in understanding the GWT concepts and usage. I highly recommend GWT In Practice!!!



3. My first thought upon reading the first few chapeters of this book was "Where was this thing when I started to use GWT a few months ago?" The authors have done an excellent job really showing how to use the Google Web Toolkit. My eternal fear when I read these books is that there won't be any content outside of what the product already ships with. Not so in this case at all.
   
   The authors cover the GWT basics, to be sure, but more importantly, they demonstrate a way to really use GWT. They hit upon one of my thoughts when first trying to get my head around GWT: GWT is not a framework; it is a platform at best. They recognize this and help you work with the power and around the limitations of GWT.
   The authors demonstrate common patterns and practices in the "language" of GWT. It was extremely satisfying to finally, with the help of this book, be able to articulate and execute all the patterns that I've been using in other systems, (e.g. MVC, PropertyListeners, etc.)
   
   The authors also demonstrate how to use GWT in a variety of environments and build system. These concepts were useful, but I found myself skimming over pages at a time to get back to the "good stuff." (This was my primary knock in not giving it five stars.)
   
   All in all, I highly recommend and I'll be ensuring that my team each learn the concepts presented.

4 comments about MCITP SQL Server 2005 Database Developer All-in-One Exam Guide (Exams 70-431, 70-441 & 70-442) (All-in-One).

1. The end-of-chapter exam questions were perfect for helping me know what I know and what I don't know. I already passed the 70-431 and 70-441 exams and the questions I looked at in the back of the chapters hit the knowledge needed to pass these exams.
   
   Unfortunately I failed the 70-442 exam before this book was released. However, after reviewing the end-of-chapter exam questions, I saw exactly what I needed to brush up on. I spent several days in a marathon study session doing the exam questions in the back of each chapter for the 70-442. For anything I missed, I studied the material in the chapter. In addition to learning what I needed for the exam, I also learned a couple things I didn't know about in SQL Server 2005. I then took and passed the 70-442.
   
   This book was just what I needed. I only wish I had it before I took the 70-442 the first time.



2. For the 431 exam, I used the (Tom) Carpenter book as my primary study guide and this book as a side reference. My main reason for purchasing this book is for the next two exams (441,442). After taking the 431 test and looking up some questions I guessed at in this book, I regret not using this book as my primary study guide. This book seems to point out the exact information needed to get through the test. I look forward to using it for the next two exams. Note that the author of this book is the technical editor for the Carpenter book.
   
   Update to previous review:
   I just passed both exams (441 & 442) without difficulty and with plenty of time remaining (each exam took about 2 hours). This is definitely the book to use for these exams. The topics and sample questions are on target with the actual test. Be sure to review the topic list for each exam in the front of the book before taking the test. The 'what you need to know' section at the end of each chapter is not always accurate. Also - the explanation of cascade deletes is incorrect in the book.



3. Well written and in depth, this book should cover everything necessary to pass these tests.
   
   I have two complaints:
   
   1) The book is laid out functionally for SQL Server, not for each test. So, for example, when you are studying for the 70-442, it may involve a portion of chapter 3, 4, 5, and 8, but all of 12 and 13. All this information is entwined with the stuff for the other tests.
   
   2) You choose to only take one of the tests on the CD. For example - you couldn't say just test for the 70-441 test. I found the CD questions less useful than books dedicated to one test because of this.
   
   These are minor complaints though, and I'm not really sure the issues can be avoided to begin with. Don't let them stop you from using this as your resource to pass these three tests.



4. After having completed Microsoft's MCAD certification, I am using this text along with the Tom Carpenter text to prepare for MCTS and MCITP certification. Though I haven't taken the exam yet, the material appears to be covered in a thorough and in-depth fashion. Yet, it does not get bogged down in unnecessary detail.
   
   Excellent book!

1 comments about .NET Domain-Driven Design with C#: Problem - Design - Solution (Programmer to Programmer).

1. I've been playing with Domain Driven Design off-and-on for about a year now. I've read the Evans book (Domain-Driven Design: Tackling Complexity in the Heart of Software), the Nillson book (Applying Domain-Driven Design and Patterns: With Examples in C# and .NET), and the Fowler book (Patterns of Enterprise Application Architecture (The Addison-Wesley Signature Series)), but what I really need is a real-world reference app to put all these concepts together.
   
   That's what Tim McCarthy's book does. It presents an anotated reference application, a real estate construction management application built as a WPF smart client. McCarthy's writing is clear and to-the-point--he simply provides a running commentary on the reference app from a sequence-of-development perspective. He starts with a skeleton and builds out the app from there, discussing his refactorings as he goes. I find this very helpful as a template for developing my own DDD apps.
   
   The reference app is written in C#, as are the book's code snippets. However, since most of the code discussed boils down to .NET calls, even VB users with only limited experience with C# may find it useful. As C# is my language of choice, it did not present any problem for me.
   
   This is a really good book; the best I've bought in a while. I do not hesitate to recommend it to any developer learning DDD in C#.

No comments about Microsoft Outlook 2007 Programming: Jumpstart for Power Users and Administrators.

5 comments about Refactoring to Patterns (The Addison-Wesley Signature Series).

1. Well done book, and a valuable next-step in learning about design patterns. The original GOF presents them in isolated and rather sterile format and manner, this book adds a much richer context and analysis in actually using them in application refactorings.



2. this is definitely the best book about design pattern I have ever read.
   
   but this book is not telling you what a pattern is and how to use this pattern; instead, it shows some inappropriate designed structure and explains what might be the reason of the inappropriate design, then suggests one pattern to help you out. it's an excellent idea to describe a pattern and the samples are interesting.
   
   moreover, the book is paperback, thin, small, easy to carry, what else can u ask for :D



3. A master-piece and a must-read art-work. When I was studying on Martin Fowler's Refactoring to make my code more comprehensive and improve its clarification, I see, Martin Fowler's techiques are generalized techniques, I found Joshua Kerievsky's techiques in Refactoring to Patterns are more specific techiques concern of purely Design Patterns. While Design Patterns itself high-level abstracted, it is easy to find concrete examples in Recfactoring to Patterns and that makes programmer easy to understand Design Patterns. Special thanks to Joshua Kerievsky and to his study group for a this kind of work.



4. Clean up (refactoring) is fun. Clean up to the design level (patterns) is stunning. A very pragmatic introduction, down to the code and incredibly helpful. Even strong procrastinators develop an appetite for this often little loved part of our work.
   
   Now what are the prerequisites: You should have read and maybe even handy the landmark book "Refactoring" by Martin Fowler and colleagues. You need a working knowledge of design patterns. You have to actually like real code. Everything else is contained in this beautiful book.
   
   The writing style is lucid and the topic is explained in a refactoring fashion: Readers are guided through the subject with real code (somewhat simplified) in small steps at a slow speed step by step. It is amazing how much ground you cover this way and how fast.
   
   I do highly recommend this book for every software developer.



5. There are a lot of nuggets of wisdom in the book, especially in the pragmatic approach the author takes to refactoring and patterns. He admits that patterns can make code worse, or better, depending on the need and skill of the author. He also provides a number of clear examples. However, the style of the book is like the dull works I had to read in graduate school, unnecessarily littered with citations. He cites Fowler to such an obscene degree that it looks more like academic backslapping. Citations are fine when doing a review of literature or examining research, but when they are used for mere quotations, the style is intrusive. As a final complaint, I found that I could often read a whole page and reduce it to one or two sentences. Curiously, he cites an example of Benjamin Franklin trimming a long phrase down to a single person's name. I wish he would have refactored the book in the same way. Almost all programming practices books suffer in the same way: dull, ungodly verbose, academic, and making unnecessary deviations from the point at hand. My suggestion is to get good at skimming, and you will find this book to be worthwhile.

5 comments about Drupal 5 Themes.

1. A few months back, I was sent a review copy of Drupal 5 Themes by Ric Shreves from Packt Publishing. I have been thumbing through it since, and despite some odd editing I have found it to be very easy to read. The examples strongly illustrate concepts through out.
   
   I really enjoyed the first couple of chapters which reinforced concepts that I already grasped providing very basic Drupal management and configuration and discussing what makes a Drupal theme. It goes on to illustrate setup and configuration. Chapter 3 looks at Theme engines--in depth for PHPTemplate and then touches on other engines. Chapter 4 explores style sheets. Chapter 5 looks at intercepts and overrides. Chapter 6 covers modifying existing themes using Zen primarily as the example theme. Chapter 7 explains the process to create a new theme from scratch. Finally Chapter 8 covers forms. Each chapter has a concise summary that re-iterates what was learned in during the chapter.
   
   I appreciated that some effort was put into explaining how cascading operates in CSS--a touch that will definitely help folks who are new to the sphere and made following parts of the book much more accessible.
   There is a form to download a copy of the sample files in the book. When you put in your request, an automatic email will be sent to you--be patient, it will take a few minutes for it to get to you. The email will contain a link to a ZIP file containing the files.
   
   Interestingly, there wasn't any information on two tools that I was taught back in the days of 4.x--CCK and Views. This seems to me to be an oversight given the prevalence of sites using CCK and Views.\
   
   This book is terrific for a beginner who is getting his or her feet wet in Drupal theming. It makes for a strong reference for themers with more experience as well. I've got to say, that it has inspired me to dig deeper into the theme layer of Drupal and has provided me with insight that helps me to understand what our themers at work are engaged in.
   All in all, I enjoyed the read and can recommend it.



2. The first thing new Drupal developers ask me is, "How do I make my new Drupal site look different from the rest?" Drupal 5 Themes by Ric Shreves is the first book dedicated entirely to theming Drupal. This topic certainly deserves its own book and I'm glad we now have it. (On the down side Drupal 6 is already released and Drupal 7 is in the works.)
   
   Somehow I've been able to avoid advanced theming by using sub-contractors or taking themes from the Drupal Theme Garden. But I realize that designers and programmers cannot go it alone. In order to build the most interactive sites, we need to reach across the gap and learn a bit about each other's craft. Enter Drupal 5 Themes.
   
   The book is written for designers who need to learn some base level Drupal theming. It covers Drupal's use of the abstraction layer in a way that is easy to understand. And while the pace and brevity are appropriate for the non-programmer, be prepared to look at some code: Chapter 8 does a good job of exposing novices to the template.php file and the form_alter api, allowing them to take advantage of some of Drupal's more advanced modification options.
   
   As a programmer, my favorite section was Chapter 4 - A guide to Themeable Functions (p.87)--it makes an excellent quick reference guide by listing theme functions and their definitions, organized by module. I find these sorts of things super useful, relieving the poor souls who answer my endless questions in the Drupal-support IRC channel about "What is the right theme function to use?"
   
   But this list, as well as the book in general, is limited as it only addresses theme functions in the Drupal core. Most sites I've developed have 20+ modules loaded, in addition to the Drupal core. It would be great to have additional references for popular modules and their theme functions. For instance, the Content Construction Kit and Views modules are becoming the preferred way of building forms, detail pages, and lists, therefore deserve addressing.
   
   I recommend this book to designers who need to learn some Drupal, as well as to new Drupal programmers who are looking to get a handle on Drupal's abstracted theme layer. But the established Drupal programmer, like myself, will find it a little too brief and lacking in real world use cases, considering Drupal's modular capabilities.



3. Great book for web-designers/developers who start with Drupal 6 Themes. Can't wait for the Drupal 6 version or a book that addresses the more experienced Drupal Developers.



4. This book is exactly what I have been looking for. Being pretty new to Drupal I had been using the documentation at the Drupal site. It is good for starting off but my company, Savant Creative Group - [...] - needs to develop our own themes. The book is well written, well documented and not too heavy on PHP. It is great for design people who know html and css.



5. Going through the pages of "Drupal 5 Themes" I kept thinking how useful it would have been to have this book in my hands a little over a year ago, as I was first dabbling with Drupal. This title complements very nicely Drupal: Creating Blogs, Forums, Portals, and Community Websites by focusing on making your Drupal-based site look and feel the way you want it to, departing as much as possible from the native themes available through the Drupal community.
   
   The book is not meant for those who are not familiar with a bit of PHP and CSS and should not be tackled before being clear on the basics of Drupal. The only downside to the book as far as I am concerned is the lack of color in the illustrations: while not critical, it would help get the point across better in a few places.

No comments about XSLT, 2nd Edition.