5 comments about Advanced Microsoft Office Documents 2007 Edition Inside Out.

1. As a Microsoft Office programs training instructor in my own business, and a part-time Office Programs Instructor for two local Community College Workforce Dept's., I find the Advanced Microsoft Office Documents 2007 Edition Inside Out to be a very comprehensive book that is very helpful to even experienced users, as well as new users. The written and graphic details are very simple, yet concise, and make the learning process much easier. It is a book that I not only recommend to my students and clients, but, it also has a home on my own desk.



2. I want everyone in the office to have a copy (and actually read it!). I would recommend this for students, as well.



3. This book is the only Word/Excel related handbook that actually discusses the merits of various ways of pasting Excel charts into Word documents (pp. 142-151). Wempen's Using Word book discusses it and gets it wrong. The Word Inside Out book doesn't bring it up.
   
   I'm rating this book on this fact alone, so it is not a complete assessment.



4. The content of this book is fine, but the quality of the book itself is poor. Pages are falling out already and I've only used it a few times.



5. Once of the best tech books I've ever read - lots of rich detail, my favorite thing is that she spends time explaining how previous versions lead to this one. Very easy and enjoyable - yes, enjoyable - to read.

5 comments about Pro .NET 2.0 Windows Forms and Custom Controls in C#.

1. Since the moment when I took this book in my hands and was able to make practice with the examples on this book, I was able to feel recognized the simplicity in the complexity of the controls.
   
   The examples are clear and very well done, impeccables and flawless a good thing for the newbie and the old programmer.
   
   I am enjoying the controls that allow me to click on them and assign my own properties.



2. I've read quite a few books on Windows Forms applications which include creating custom controls. There are some that are average and there are some that are very good. Usually the average books tend to touch on the simpler aspects of windows forms and forms controls and not go into much detail, which is OK for the novice programmer dabbling in .NET for the first time. However, the more experienced programmers among us want much more. In this respect the very good books tend to be a little over the top for the average user.
   
   This book falls somewhere in the middle for novice and experienced programmers alike, whilst still being rather good. It offers a good discussion on what makes up the underlying architecture of Windows Forms applications which many books lack. The .NET IDE attempts to hide a lot of the nuts and bolts behind the outer layers and generally you shouldn't touch what's under the covers. But occasionally you need to, especially when using visual inheritance because that's when the IDE starts the go a little haywire. By understanding a little about what's happening underneath goes a long way in helping you get out of the mess when the IDE does screw up.
   
   The book covers most of the interesting forms controls .NET 2.0 has to offer and describes them in better detail than what can be found in the relatively useless MSDN on-line help. The code examples given are excellent, concentrating on real-world scenarios. A good portion of the book illustrates how to extend these controls further using custom controls and GDI+ owner drawing to modify the look and feel of these controls.
   
   The book also concentrates on developing 3-tier applications isolating the presentation layer from the business logic and data layers, which is a highly recommended practice for developing scalable applications.
   
   The book doesn't include a CD but all the code examples can be downloaded from the publisher's web site.
   
   Overall I give it 4 out of 5.



3. I checked this book out online and only read chapter 20(multithreading). In this chapter the author does an excelent job progressively building your knowledge about .net Threading. I would highly recommend reading this book to anyone wanting to learn about Threading.
   
   The only downfall about this chapter is that it does not talk about some of the more advanced Threading classes such as Monitor and ReaderWriterLock. I would love for this author to do a standalone book just about threading.



4. I needed this book for a training course on Windows development in .Net. It helped a great deal to have a good reference that was not the same as the book used in the course. Sometimes I found the examples a little hard to follow because of the distraction of the scenarios shown, but when I boiled them down to what they were meant to present, they were very helpful.



5. This book has already paid for itself in just a couple of weeks -- due to the time saved in trying to find the information I need. Every time I have a question regarding an issue in Windows Forms or with Custom & User Controls, I can find it here. Additionally, the content is written in a manner that can be understood by mere mortals, with some good tips and tricks thrown in too.
   
   Highly recommended.
   
   On the merits of this text, I've already purchased Matthew MacDonald's WPF book (the 3.0 one, since I haven't *quite* moved to VS 2008 yet...).

5 comments about Refactoring to Patterns (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.

No comments about Pragmatic Thinking and Learning: Refactor Your Wetware.

5 comments about Microsoft® Office Outlook® 2003 Inside Out.

1. A most comprehensive treatment of Outlook. Extremely well suited for an experienced Outlook user, with many details on the use in a server/business environment. Describes the interrelationship with Windows Outlook Express. Probably a little too comprehensive for the single system user just trying to read and write a few email messages. Subject matter is exceptionally well presented and thorough.



2. Previous reviewer's comments are noted well, but I was somewhat disappointed in the coverage of forms development. I really wanted to learn to move/place fields on a contact form and designate them drop-down, etc. Simple enough, I thought, for a book of this coverage. But even though the author talked about the abilitiy to do this, there were no directions, no examples, and no description of the 'Controls' options required to do it. For a book of this size and price, I had hoped for more meat. No, not to the detail of VB scripting, but certainly more detailed coverage of Outlook's powerful forms and macro abilities. To my chagrin, I'm finding my answers under the Outlook 'Help' section in the program itself!



3. Too much said about the various steps. Not brief and to the point. Found it difficult to go step by step without reading, and reading, and reading.



4. Comprehensive and approachable. Good index and highly illustrated.



5. I found myself as the Outlook support for a new small business and I had only used Outlook for e-mail and contacts previously. This book has quickly become my total reference guide. It has helped me solve several problems. It's easy to read, well organized and very complete.
   I recommend it to anyone who needs to support an Outlook installation or an Exchange Server installation.

5 comments about Pragmatic Version Control: Using Subversion (The Pragmatic Starter Kit Series)(2nd Edition).

1. This book is targeted at someone who is likely already familiar with version control systems (as it frequently refers back to differences with CVS), yet tries to be for the beginner as well. As an experienced user (as I am) you will have to wade through a lot of verbiage to get to what you want. The author uses a conversational style. I got all I could from this book in two frustrating hours, when what I really wanted was a more terse reference.



2. Excellent book to get kick started on SVN. The examples given in the book are very practical and reinforce learning. It would be more valuable if it could include some help for people who are looking to migrate to SVN from clearcase



3. This is my favorite technical book. I read it cover to cover, which is unusual for me but this book was just that good -- comprehensive and quite easy to understand.
   
   It helped me move from CVS to SVN smoothly and with confidence. I also find it to be a great reference to come back to for a refresher here and there.
   
   This book is for Subversion what Ansel Adams' The Camera is for photography: The perfect first step and, for some, the last step they need.



4. This book had everything a non-expert would need to understand the basics of the version control system with Subversion.
   
   The tone is very readable. And the use of graphics was good but could be better
   
   Overall, I recommend this book to anyone who is trying to build a strong foundation in source code versioning.
   
   It really cuts to the chase so the reader can be doing real work in a matter of minutes. I expect to see updates to this book.
   
   I would like the author to add a chapter or two aimed for web developers. Dreamweaver CS4 (the editor of choice for many web developers) has recently integrated a subversion client for a robust checkout and checkin. It would be nice to see a chapter on how to setup and configure a site in Dreamweaver cs4 with subversion as a version control system.
   
   I would like to know what are the best practice of using subversion in web enviroment. How Apache, Dreamweaver and Subversion can talk to each other happily.
   
   Thanks again for writing such a wonderful book and keep the good job.



5. [Reviewed by XPSD member Andy de Torres]
   
   As the guys behind the Pragmatic Starter Kit Series admit, these books cover basic stuff all developers should know. So it comes as no surprise that Pragmatic Version Control Using Subversion is not a ground-breaking, earth shattering book. It's a good, thin, easy to read book that covers the basics of version control and how to work with Subversion. It spends fewer than 20 pages on the basics with the rest of the book covering syntax, setup, and best practices for Subversion. (Check out the CVS version of this book if you're using CVS.) An appendix of "recipes" (which could have been organized better) covers over 60 operations with a quick summary of the commands required for each and a pointer to the section of the book where it was covered. Some of the recipes are simple things that you tend to do from your IDE plug-in or TortoiseSVN or other client, but many are more involved. This is very helpful, because many tasks are infrequently performed, and you can spend a lot of time (in other books) searching for where a topic was covered.
   
   I found the book very helpful in getting Subversion installed with Apache for HTTP-based use (through firewalls) in just a few minutes and also for local use on a USB flash drive (with file-based URLs) as well as for organizing my repository. When the time comes, I will refer back to their "recipes" for dealing with release issues. I would not hesitate to recommend this book to anyone using or considering using Subversion.

5 comments about Pragmatic Unit Testing in C# with NUnit, 2nd Edition.

1. You keep hearing about it.
   "Unit Testing, Unit Testing, Unit Testing"
   The time is now. Stop talking about and start becoming a more responsible developer.
   This book takes you through the scenarios. Well written, and easy to get going.
   This book has been the key ingrediant to get other developers at my company involved with NUnit testing.
   
   NUnit is freely available. If you have VS2005Pro, then plugging in NUnit make the most sense.



2. This is a great introduction to writing unit tests in C# with NUnit. The authors do a good job of explaining why unit tests should be created, how having unit tests are better than not having unit tests, and what exactly should be coded for in a unit test. The book is well-written, easy to follow, and includes helpful guidelines for things that might be confusing to developers.
   
   The real strength of this book is not the author's approach to writing unit tests, but rather they clearly illustrate what exactly should be tested in a unit test. The authors show how adhering to the guidelines they set forth results in unit tests that are well-written and fail at appropriate times. The authors then generalize this to some extent and provide an excellent discussion on the properties of a good unit test.
   
   My favorite section of the book was actually one of the appendices. In the first appendix, the authors go through a list of gotchas--both in writing unit tests in general and specific to unit tests in C#. This is a very short discussion (only 6 pages), but they identify some issues I've seen with poorly written unit tests.
   
   This is a great book as an introduction to writing unit tests. The authors clearly explain why unit tests should be written, they show clearly what should be tested in a unit test, and they describe some of the problems that have been avoided by writing intelligent unit tests.



3. The book is packed with practical advice on unit testing. Why should you do unit testing, what do you need to know to write good tests, how do you know if you're writing good tests, how can unit tests not only improve your code, but also your design, can unit tests doom a project (if not done right) --- you'll find answers to all of these questions and more. The authors also give numerous short code examples that help solidify the concepts. You'll also find extensive references and links to web-sites where appropriate. The authors' writing style is fluid. If you enjoy reading good technical books, you'll read this like a novel!



4. I have to respectfully disagree with all the fawning reviews. It's a chatty, drawn out, tedious read, something of an accomplishment given the fact that it's only ~200 pages long. Frankly, anything more then something like the O'Reilly Pocket Reference is overkill on this subject. NUnit is a snap to use and the freely available documentation and tutorials are more than adequate and not nearly so time-consuming to digest.
   
   The first passage that discusses actual test coding (~20 pages or so into the book) presents a simple case where a method should accept an integer array as a parameter and return the largest element. The book then explains how this function, if it behaves properly, should perform. A series of simple test cases are discussed before we get to the real toughie for all you computer scientists out there - a data set consisting of negative integers. A test vector consisting of the array [-9,-8,-7] is passed to the method and -7 is returned. The book explains 'It might look odd, but indeed -7 is larger than -9. We're glad we straightened that out now, rather than in the debugger or in production code where it might not be so obvious.'
   
   ARE YOU KIDDING ME?!? Just what audience was this thing written for? One would have thought that that little gem wouldn't have been necessary... but in fact that is the tone of the entire book. Expect to have your hand held in this manner throughout. If that's the sort of thing that appeals to you, you'll love this one. If, on the other hand, you're trying to learn to incorporate NUnit testing into C# development in an efficient, professional manner, save your money and time and read the NUnit docs.



5. This is a decent getting started book, but it doesn't give good coverage of things such as NUnit projects or using app.config files with NUnit.
   
   Unfortunately, this book isn't good as a stand-alone. I'll admit that it did help me get started, but it lacks so much that I can't give it more stars. A second volume that covers more advanced topics is suggested, or the next edition can add the missing parts.

No comments about MCITP Self-Paced Training Kit (Exam 70-238): Deploying Messaging Solutions with Microsoft Exchange Server 2007.

5 comments about Eclipse Distilled (Eclipse Series).

1. With Eclipse becoming extremely popular as an integrated development environment, there have been a number of books published to help you learn the tool. I recently received a copy of Eclipse Distilled by David Carlson, and it's a pretty good addition to the collection...
   
   Contents:
   Part 1 - Getting Started: A Java IDE and So Much More!; Hello Eclipse; Managing Your Projects; Customizing Your Workbench; Rapid Development; Java Project Configuration; Debugging Your Code
   Part 2 - Getting Agile: Characteristics of Agile Development; Updating the Eclipse IDE; Continuous Testing with JUnit; Refactoring Your Code; Continuous Integration with Ant; Team Ownership with CVS; Coding Standards; Index
   
   If you're looking for a book that covers a large number of the features of the Eclipse IDE, this book will be a good choice. In addition to covering all the technical details for installation, options, and "how to" things like refactoring, the author also covers how Eclipse works with various other common programming tools like JUnit and CVS. It's not a definitive guide on these other software packages, but you'll get a good grounding on how they integrate.
   
   What this book *isn't* is a tutorial guide to learning Eclipse. There are a number of Eclipse books that will walk you through a number of examples of how the package works and how to write code with it. This book really doesn't do that. You'll find out a lot about all the different options, but it's not like a "step 1, step 2, step 3" presentation. I really don't consider this a detriment to the book. If I wanted a tutorial, I could find one. But if I want a book that shows me all the mechanics and let's me figure out how to apply them to my needs, the "Distilled" approach works great.
   
   I like the book, but I can see how some people might not be enamored with the lack of sample code. If you're going in with your eyes open, you should be fine...



2. In his forward, David Carlson writes: "This is the book I wanted to read when I started using Eclipse three years ago." Wow! And this is the book I wanted to read too!
   
   Like husbands and wives, wrenches and nuts, hands and gloves, some things were meant to fit together, while others repel like oil and water. When I learn a new programming language, IDE, API, software program, etc. I want the basics, the practical, the stuff I really need to get going. In any of these endeavors, there is simply too much to learn to sit reading detailed information on features that just never come up for me. Give me a good grounding in the basics, and I will pick up the details on the fly when I need them.
   
   Carlson's book will get you up to speed fast. Furthermore, it gives you the basics on several of the latest development methods with which Eclipse is compatible. He provides excellent basic discussions of Agile Development, JUnit testing, Ant, refactoring and the Concurrent Version System. He easily fits all this information into less than 300 pages.
   
   If this approach fits you like it fits me: Quick! Buy this book and get started.



3. I manage multiple developers spread around the globe building product relying on the Eclipse Web Standard Tools (WST) and other parts of Eclipse. Getting each team member's IDE configured and updated was sucking up time.
   
   Chapter 9, "Updating the Eclipse IDE," saved us time equivalent to purchasing boxes of the book. Now we have flexible, consistent, repeatable configurations that make upgrading to new versions of WST and other features easy.
   
   We have adjusted our team's practices based on info in other chapters too.
   
   Carlson has provided excellent information for developers who want to work more effectively in the Eclipse environment. I'm delighted with the purchase.



4. I read this book end to end but didnt find even a single startling fact about eclipse that i didnt know already.It was more like feature round up ( which you can discover going through the menu items in eclipse IDE)
   I would recommend this book for people who are absolutly new to eclipse .



5. This is an excellent book and I recommend it highly to start with Eclipse.
   It saved me an incredible amount of time by providing the right level of information on virtually all important features of Eclipse.
   This book is for people with a background in development, but new to Eclipse.

5 comments about Hibernate in Action (In Action series).

1. With this book, we have the rare circumstance where the founder and principal developer of the technology has authored the material. Moreover, the back jacket promises that the text would build on a single example to show how to use Hibernate in practice.
   
   Sorry, dear reader. This book falls far, far short of its promise. Yes, you can download a single cogent example. But the authors make only loose reference to that example, choosing instead to offer dozens and dozens of snippets, out of context with the example. A first-class book, such as Mastering WebLogic, not only provides a robust example, but also walks the reader entirely through the example, from design choice, through coding practices, and ultimately into implementation decisions. In stark contrast, this book offers nothing more than a progression through various topics, illustrated via pieces of java classes, leaving the reader to hunt for the relevance to the downloadable application.
   
   The book does have its uses. As you dive into various real-world situations, this book should serve, after some digging, to reveal an optimal approach to solving the problem at hand. The topics are covered to a healthy depth. I suspect this is the best treatise available on abstruse topics such as caching, transaction handling, and mapping to legacy data stores.



2. I found this book useful and readable, and it helped me develop my first (and second) Hibernate applications. It begins with a brief overview of the kinds of problems which ORM solutions need to address. It then introduces Hibernate along with a couple of examples, upon which subsequent chapters build. (Some reviewers have criticized the examples, but I thought they were useful, and I didn't have trouble following them) One thing you should be aware of: while this book is a good narrative, it's not as useful as a reference. I find myself paging back and forth among several chapters which cover topics in different levels of detail. That shouldn't be a show-stopper since reference material exists on the web. You might be concerned is the book covers Hibernate 2.1, while Hibernate 3.x and Ejb 3 are out; the book is still relevant and valid, and I've used it along side Hibernate 3 with no problem.



3. This book is for Hibernate 2. Hibernate 3 is covered by the same authors in Java Persistence with Hibernate



4. A great book for getting going with Hibernate quickly.
   Some parts are heavy going because it is packed with info. This pays off because there is little or no padding/rubbish.



5. In an age where many technical books are full of typos if not outright misinformation, Hibernate in Action stands out as very well written. It seems that spell-checking has replaced editing for many technical books. This book is not only informational, but easy to comprehend.
   
   The only down side to this book is that it is now somewhat dated in that it does not cover the current release of Hibernate. Nothing on annotations, etc. However, this book is not merely "The Professional Learn Framework X Bible in 23 Days" API memorization aide. Hibernate in Action provides you with the theory of why to use an Object Relational Mapping (ORM) framework and how to best leverage this knowledge. This information is not Hibernate specific and does not lose value with the inevitable new release.