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.

1 comments about Workbook to accompany Anatomy & Physiology Revealed Version 2 CD.

1. I'm currently preparing for my Physician Assistant program that starts afer summer. I had heard that Advanced Anatomy is pretty tough, and since it's one of my first classes coming up first, I wanted to seriously review. I used Vander's for my university Physiology class, and the Broyle's CD software was advertised. I took a chance and...wow. I ordered a few other texts along with this CD/manual, most of the recommended books, but this has turned out to be superior in it's approach and guidance.
   
   The workbook takes you through the software step by step (the software is amazing, by the way), with a degree of detail that would otherwise have been intimidating. Each and every area and aspect is explained with a fine level of focus. As someone who scored quite well in Anatomy, and who worked for a year in my school's anatomy labs, I'm very impressed and now feel greatly prepared for what's to come.
   
   *warning* This workbook is for serious students, it's not a general overview. Use it along with Netter's, Rohen's, or another of the recommended texts, for comparison and backup. Excellent!

5 comments about Programming .NET Components, 2nd Edition.

1. Book goes through the entire process of building controls, nothing is untouched. It dwells however much too long on the 'standard' topics of installation, distribution, setting up etc and is rather lite on the the real stuff like building controls that look and feel like commercial controls. Would be a good book if it had 20% of the pages.



2. While going over component and control design, this book teaches the principles of the component-oriented design philosophy. The author doesn't pander and isn't overly verbose; getting to the point and explaining his meaning efficiently and succinctly. Definitely worth the read.



3. This book is incredibilly well written and has a very comprehensive way of explaining the ways of Component oriented programing. Explains its differences betweent COP and OOP. You can easily understand what the author has in mind, BUT, I found one big flaw on this book. Not that this flaw will make the book less comprehensive, but it will make it less fun.
   In all concepts it presents Examples, but not exercises. It explains the features and then give a short example to it. It doesn't stimulate the reader to actually build a code within a major context. You read, see the example and move on to the next topic. It is not fun to just stay around and read and read and read without actually working with the book. It is still a great book, but the approach to the reader could be better.



4. Without any second thought I will place this book among the best books on the subject ever published. I hope everybody will agree that there are only a few books that worth reading from the beginning to the end without skipping a page. To me this is one of those rare books.
   The author manages to reflect on broad architectural concepts and yet be extremely specific. He was able to present the most complicated aspects of component oriented programming and the C# language in a very simple, yet concise manner. Many complex issues that may turn off even experienced programmers are described in a way that not only are very well understood, but could easily be migrated into a working program. The author has found an absolutely perfect balance of presenting general architectural aspects of the subject he is discussing and real life implementation techniques.
   I truly believe that anybody who is dealing with such aspects (to name but a few) as serialization, asynchronous invocation, multithreading, reflection, events, delegates, deterministic finalization, etc., MUST read this book.
   By the way, this author has published another wonderful book on Windows Communication Foundation - "Programming WCF".



5. A Classic Book that begins it's journey, where all books end. The true difference between a casual programmer and a disciplined programmer is more prominent in his/her code when they start using advanced features of the framework. A true programmer knows his stuff in and out and knows how to leverage the features of the framework effectively in every line of code. And to get to that level of proficiency it takes reading and practicing the concepts on daily basis. And if at all, there is any book out there, that will help you, then it is this book. A definite YES. 5 Stars.

3 comments about C# 3.0 Pocket Reference: Instant Help for C# 3.0 Programmers (Pocket Reference (O'Reilly)).

1. As C# is a complex language, there are lots of things that we, C# programmers, need to know when writing some code. With so many things to learn and so many features available, how can we remember all the syntax and all the details of everything in C#? The answer is: We can't. Everytime we forget something, we go look for help in the internet, don't we?
   
   So this book is pretty much of this: Why search the internet and waste a lot of your precious time visiting tons of websites that doesn't have the information that you need until you find a website that has something to help you, if you have a book that you can carry everywhere and search for all those things in a very quick way?
   
   Although this book explains most of the features to you, I don't recommend it for those who want to learn C#. This book is a great help for those who already know C# and want to have a reliable reference or even get a closer look at the new features in C# 3.0.
   
   If you don't know any of the new features in C# 3.0, or if you don't know C#, I recommend that you read a book that describe the features in a more detailed way, like C# 3.0 in a Nutshell.



2. I read a wonderful, but huge book by Andrew Troelsen and wanted a small reference book to carry around. This little book has such short, yet illuminating descriptions and examples of all the keywords and types I've looked up so far. A few standouts are the sections on Events and Generics.
   I've had this less than 24 hours and it has already paid for itself.
   Truly a superb effort by the Albahari brothers. I will definitely be ordering the Nutshell book by the same authors.



3. I agree with the positive comments of the other reviews but would recommend this book for learning C#. It is well structured for the purpose of learning the language and does not assume familiarity with it: it defines the necessary concepts.
   Even though programming is a very logical enterprise, programming books have a tradition of extreme verbosity, and so I hope this series continues to grow because it is almost the only place one can get the concision that allows for quick learning.

5 comments about Applications = Code + Markup: A Guide to the Microsoft Windows Presentation Foundation (Pro - Developer).

1. I think that Petzold was reading my mind when he wrote this book. I don't like XML, and I don't like "cheating" with XAML when you can write good clean C#. The first half of this book is entirely C# programming in WPF. I am using this book to help me write an abstraction layer above WPF. That simply would not be possible with XAML, which in my opinion places the design of the application at too low of a level. Petzold leaves no stone unturned, and whenever something seems weird, he doesn't ask us to trust him that it makes sense; he explores it in depth for us. I can't imagine that many other authors go through that kind of trouble when they're writing on tight deadlines. Petzold tells it how it is, and he includes the "why." Therefore, I recommend this book to anyone who strives to become a bit of an expert in WPF, not just a get-the-job-done programmer. I would consider this an advanced book at times because I find myself reading and re-reading sections to understand it. The explanation is there, but it's not trivial, and with so many pages in the book already, there is no room to be wordy.



2. I've been a Windows developer for around 10 years or so and have read dozens of developer books. This is only the second one I can remember returning.
   
   I had previously read Programming Windows Presentation Foundation (Programming) (which I recommend) but was looking for more. At 900+ pages, and with the good reviews and experience of the author, this book looked like a good choice. Unfortunately, after the first 450 pages, I decided that my time would be much better spent simply rereading the the Chris Sells book instead.
   
   The main problem is the style in which the book is written. It could easily be edited down to half its size. How many times do I need to read "Button btn = New Button()" in a code example? I know some people prefer fully functional examples over code snippets but after a while it really got ridiculous. The code examples eventually became almost useless to read because it became so much work to sort out the irrelevant and insignificant details. On top of which 90% of the code samples are examples of THE WRONG WAY to do a UI in WPF (i.e. in C# instead of XAML). I understand the second half of the book is all XAML, but spending 450+ pages on techniques you would NEVER ACTUALLY USE is a waste of my time.
   
   A lot of bloat also came from a lack of focus on who the book is written for: experienced .NET/C# developers. I don't need to have "using" statements explained to me, I know how .NET dialogs work, etc... From the "Printing" chapter: "The Print dialog also includes a Number of Copies field. Enter a number greater than 1 in this field and the PrintVisual method prints multiple copies." Really. I never would have figured that out on my own.
   
   There is a lot of good information here but it is simply not worth the time it takes to extract it from "Button btn = new Button()" statements. Maybe this book is a demonstration that you're never to old for an editor. I'm going back to O'Reilly books.



3. This book seems to have had several negative reviews.
   The gist of most people's complaints seem to be:
   
   (a) "There's no XAML until Chapter 19" and/or
   
   (b) "There aren't any pictures".
   
   The Complaints - are they justified?
   
   a. No XAML
   
   People making this complaint have in my opinion totally missed the point for several reasons.
   
   Firstly, this is not Charles Petzold's "How to Write XAML" book. It's a book whose title explicitly tells you that it will approach WPF from both the code (C#) and markup (XAML) perspectives. Unusually (actually I think it is uniquely) he doesn't mix and chop up the two approaches, but deals with each of them in isolation.
   
   Secondly, WPF is not XAML. You can use XAML, sure. You'd be silly not to in many situations. But XAML is only one part of the big picture. As this book clearly shows, you can successfully create an awful lot of WPF output with code alone.
   
   b. No Pictures
   
   Normally I would have some sympathy with Complaint (b) because it's always nice to see what the code samples should produce. But if you use this book as the author intended and actually run the samples yourself you will gain far more than any quick glance at a screenshot would give you. You will gain insight and experience in how to master this new technology.
   
   The Book
   
   This is a book that very carefully works its way through the requirements needed for the reader to achieve a thorough understanding of the major concepts. One of the reasons why I recommend reading it - and using it - from cover to cover is that, even in the early basic chapters little gems of code and explanation are slipped into the narrative or the examples. Often these begin to deal with more complex topics that you will come on to in more detail later.
   
   It is crammed full of detail. Mostly it's the kind of detail that you really need once you've got past the "let's play with WPF and see what you can knock out in a couple of hours" stage. The detail you need when you move on to the point where you want to do something that isn't necessarily easy out of the box, but is achievable if your understanding is built on stone, not sand.
   
   If I have a complaint, it's a minor one: occasionally he lets the Math geek get out and play a bit more than strictly necessary, but even that is fairly rare.
   
   The code samples are in C# only. However, Young Joo on the VB Team at Microsoft has organised for some chapters to be translated to VB.NET and there are more to come. You can access them from here: http://blogs.msdn.com/vbteam/archive/2008/01/07/petzold-wpf-book-sample-conversion-new-chapters-young-joo.aspx .
   
   Summary
   
   If you are committed to fully understanding WPF then this book is one you really should buy. By all means get others too. I already have several; they all serve their purpose, are very useful and I refer to them regularly. But when it comes right down to the "roll your sleeves up, go sit in a quiet place with book and PC to learn, really learn, WPF" then I think Charles Petzold has produced a (not so little) gem that will be truly helpful to you in your learning endeavours.



4. Each chapter is well thought out and develops like a good narrative. Chapters are typically 20, 25 pages and thoroughly explain a central concept. They often end with a nice lead-in to the next chapter, like "this works, but what if you wanted to ...?"
   
   When first published, no one knew what WPF things like StackPanels looked like, so people wanted screenshots everywhere. The book uses a series of concise console applications to demonstrate WPF concepts. I'm glad it does. With a screenshot on every page, the book would be 50% thicker or have less detailed info.
   
   The console apps are self-contained little apps that generally demonstrate one aspect of a WPF feature. After a few chapters, I realized I needn't read every line of code carefully, since the author gives an intro on what to look for in the sample and often an explanation after the example about any non-obvious lines of code.
   
   Other books have their place. I have several others because I sometimes want to examine some topic from several authors' POV. But for taking a programming concept and building a full explanation in clear, logical steps, no one does it better than Mr. Petzold.
   
   Whether you are going to build next-gen Windows apps or develop Silverlight 2 applications, learning WPF and XAML is essential (just as web designers must sometimes work directly with html).
   
   Visual Studio and Expression Blend make assumptions when you drag elements onto the design surface. It's easier to work directly in XAML rather than delete extraneous properties these tools add to your code.
   
   Some criticize it takes half the book before delving into XAML. Anything in XAML can be done in C# (or VB), so starting with the code is a logical foundation for understanding. For things that are easier to wire up in XAML, the author points forward to those chapters. By the time you get to chapters on XAML, if you know anything at all about it, you'll fly thru the pages, filling in gaps about how code and markup work seamlessly together.
   
   I cannot imagine thoroughly understanding WPF without having this book's comprehensive explanations available to me. I think it's a terrific book that will stand the test of time.



5. This book is ESSENTIAL for any WPF engineer. There are so many topics covered in this book that will allow you to take your WPF applications to the next level. Charles' style of writing is fantastic and easy to understand. I wouldn't neccessarily recommend this to be the book to learn WPF fro but consider it an essential source for advanced topics.

5 comments about C# Cookbook, 2nd Edition (Cookbooks (O'Reilly)).

1. Being an advanced programmer I was looking for books to use as references or to further my skills. This book has proven a valuable asset.



2. If you are just coming into C# or have been doing it for a while - it doesn't matter - BUY THIS BOOK!!! Oreilly as we all know, makes very good tech/programming books and this one is one of the best I've had so far. This will be a book that will spend much less time on my shelf and much more time next to me on my desk.



3. I came across a project that had to do with XML, and I came to love this book. It has a lot of suggestions that helped me jump start my project.
   
   I wouldn't recommend this book to learn C#- (pick up John Sharp C# step by step for that.)



4. I'm an intermediate coder, familiar with programming and I have about 1.5 years programming C#. I've already used this book(C# Cookbook 2nd edition) to write C# code navigating in and around directories and files. The examples in the book regarding "Directory Info" and "File Info" were so clear and concise, I was able to complete my programming task with almost no lost time to the learning process. What I like most was that there was not one example, but many examples for the most used functionalities. This book has already paid for itself when I consider the time it saved me the first time I needed it!



5. This is a good intro book that eliminates the need for some of the first books I bought on C#. When compared to other "cookbooks", however, this book is incredibly weak (see: XSLT Cookbook, SQL Cookbook). If you have used C# for more than 6 months, you will know how to iterate over an array, to use String.IsNullOrEmpty, get the index of a value within a string, and use a generic arraylist. These are just some of the junior "recipes" you'll see in this book. The "recipes" just exercise the fundamentals (i.e. how to boil water) rather than how the fundamentals work together to solve complex problems in elegant ways. The easier the concept, the more information. There isn't really any analysis or best-practice justification present. I'd like to see some performance analysis of generics or at least some depth on partial methods. Nothing to see here for mid-level developers. Not written or organized poorly, just simple. If it were titled "Intro to C# by example", I'd give it a higher score.

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#.

5 comments about Applying Domain-Driven Design and Patterns: With Examples in C# and .NET.

1. This is really an exellent book on DDD, I read soon after the Evans book and I must admit that is really worth money I spent on it. Sure the book is not for beginners, and it is not an introduction to DDD, I think that a background on the subject is needed to fully appreciate this book.
   
   Alk.



2. This book covers many topics and has loads of references for patterns and domain driven design. It reads a bit choppy - almost as if a conversation were taking place. Overall it is a good compliment to Eric Evan's book and would be a good guide for newcomers to patterns and agile development.



3. Read fowler's and Evan's, the book is very good but it is an extension of books of the two authors. So, to understand it completely it is better to read those before.
   
   I have not read the books that this is based but I have enjoyed it a lot.



4. The book provides a massive detailed walk through the construction of the domain-driven framework creation. It is in Jimmy Nilsson's conversational tone and that makes the book very interesting.
   
   I do wish there were a few diagrams to tie each chapter together, but that is for the reader to do.



5. I like the author's modesty (very ofter his sentences start with "I think"), his rational thinking and his quoting the relevant big guys. He uses a very nice and simple language throughout the book which makes it an easy read. But sometimes, he is dragging on a subject for too long, for that I have to give it 4.5 stars.

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...).

No comments about Beginning C# 2008 Databases: From Novice to Professional (Beginning from Novice to Professional).