Customer Reviews

ASP.NET MVC 1.0 Test Driven Development: Problem - Design - Solution (Wrox Programmer to Programmer)

5 star:		(3)
4 star:		(4)
3 star:		(2)
2 star:		(0)
1 star:		(2)

 

 

Before I get into the details of the book, it is important to know that the audience of this book is not for novice programmers or experience non ASP.NET developers. To really get value from this book, you should have some decent exposure to ASP.NET under your belt.

With that said, this book is a very good overview of both ASP.NET MVC and Test Driven Development (TDD). It takes the reader through the process of developing a whole application using the Test First methodology. I found this interesting in that some decisions Emad made initially were later refactored in the book as the application evolved and changed, which is a great way to see the value of TDD and its approach.

This book covers quite a few advanced programming concepts that may be new to you such as various Design Patterns (Strategy, Null Objects, Repository, etc...), Design Principles (Open-Closed Principle, YAGNI, DRY, Inversion of Control, Single Responsibility, Convention Over Configuration, etc...). Emad does a good job about explaining these concepts as he approaches them in the application.

About the same time that I was reading this book, I was in the process of evaluating various tools and frameworks to use for a new ASP.NET MVC v2 project I am working on. I found it interesting that Emad ended up choosing most of the same tools that I had at the time such as: MbUnit, Ninject, Moq, and jQuery. If you are familiar with tools other than the ones he chose at the time of writing this book, you should be able to easily substitute your favorite tool instead. Most of the competitors for these tools have basically the same features.

Since this is a new book, I did run across numerous typos, references to code that wasn't displayed, refactored code that wasn't indicated in the text, and several other minor issues, but all in all I knew what Emad was getting at and it wasn't hard to follow his train of thought. I plan to submit these inconsistencies to the Errata to hopefully clean up these small issues for future printings of this book.

I highly recommend downloading the source code from this book (which you can do for free). It is one of the few projects that I've seen that has a plethora of Unit Tests to look at and get an idea of how to test your ASP.NET MVC project. I've seen numerous other ASP.NET MVC projects that only have a minimal number of Unit Tests and don't really give you a good idea of how you could get good Code Coverage.

If you are interested in getting a jumpstart into both ASP.NET MVC and Test Driven Development, then I think this is a great book for you to get. However, if you aren't so sure about TDD and you just want to get up to speed on ASP.NET MVC, then I might recommend you get one of the other beginning ASP.NET MVC books.

[...]

I had to give up on this book because it contains far, far too many errors in the code.

This book was shorter than I expected (good thing), it doesn't have all the fluff and useless pages that we end up skipping anyway. It was a good walkthrough of using asp.net mvc and tdd from beginning to end.


I specifically liked his first couple of chapters where he sets up the coding environment with all the tools, plus I LOVE his selection of tools and the overview of patterns and best practices in the beginning of the book.

This was a good overview of MVC and TDD. I loved the first few chapters, and his selection of tools, it was a good read! I recommend it.

I had high hopes for this book when I picked it up. Unfortunately, the content did not deliver. While I agree that it is nice to see the author made use of some good good design patterns and principles, It just wasn't enough. First of all, if your not utilizing Test Driven Development in any MVC project, you probably should really consider gaining some insight into this methodology. MVC is perfect for TDD. Inversion of Control/Dependency Injection patterns are a no brainer also. All MVC books out there use this pattern so there was nothing new here.

The problem I have with this book is that it seemed rushed and there were numerous errors in the code. I'm wondering if this book was started with the beta version of MVC and the author attempted to refactor after the final release. In the begining of the book, the author stated he was going to use the YUI editor for the rich text component of the site. However, he actually chose to go with jWYSIWYG, a extremely light, no frills editor that is just not suited for most robust applications.

The test framework he chose was MbUnit. Why? He explains that Visual Studio has a built-in test framework (MSTest) but chose not to use it because " I didn't want to assume that you have a few thousand dollars to spare on a copy of Visual Studio". He also admitted that most of the test frameworks have a very fast dev lifecycle and that the version in the book may be slightly outdated from the one that you are likely to download. IMHO, that is bad. Most people reading this book are senior level developers making a living with Visual Studio and the tools it offers. It's very likely that they already have a copy of VS Pro or Team or they have access to it at work or through MSDN. Also, most readers will scan the beginning of the book to see what tools the author is using. MSTest is a good framework that does not have builds released every 2-5 days. I would even have preferred nUnit over mbUnit.

His choice of IoC container is subjective. He chose Ninject. Personally, I think Castle or the MS Enterprise library would have been a better choice. Ninject relies on "contextual binding" rather than XML config files. That means you cannot alter your apps configuration after it has been compiled. Personally, I don't like that, but it's a preference.

That said, I do think Moq and jQuery were excellent choices. I really would have liked to see this project built with more standard tools and the code examples checked more thoroughly. As it is, it's an OK book on ASP.NET MVC but there are better ones out there.

What I liked most about this book was the "documentary" format. I was able to learn quite a bit about [...], TDD, Inversion of Control and even some jQuery by building the book's EvenContact project chapter by chapter. Having the downloaded source code available for comparison was key. There were some differences between the printed code blocks and the downloaded code. While some readers might see this an issue, I found that the process of figuring out these differences contributed greatly to my understanding of how all the pieces fit together. Great job Emad and thank you for saving me so much time coming up the [...] MVC and TDD learning curves!

Not a book for a novice or someone not familiarity with ASP.NET development. Found it hard to get through the book. Although the book isn't hard in itself, I just didn't find the style interesting. This is all personal and someone else might have a completely different reaction to the book.

The author chooses to use MbUnit, Ninject, Moq, and jQuery. Having not use MbUnit, Ninject and Moq before it did add to the learning curve. If you like these tools, or want to become more familiar with them this would be a good book. Preferring to use other tools I did not get as much out of the book as could be gotten.

If the reader likes the tools the author uses this could be a very good book for them. Although MVC 2.0 was just release, so the reader might want to wait for an undated book.

This book is a nice way to become familiar with Microsoft's ASP.NET MVC Framework and Test Driven Development (TDD) all at once. The author weaves TDD concepts and other development best practices into the MVC development process.

The author's writing style is easy to digest and follow and the book is short and to the point. Background concepts are not discuessed in too much depth, just enough to provide a enough understanding to 'get' what is being built (and why). Recent .NET Framework features such as LINQ to SQL and Extension Methods are used throughout the book, as are many core ASP.NET features including Master Pages and the Membership provider. JavaScript libraries discussed in the book are jQuery and Yahoo's YUI.

If you want to expand your web development knowledge and learn ASP.NET MVC and TDD along the way, I recommend picking up a copy.

The author seems to be well versed with TDD and explains the concept very well. He starts off with a high level design and slowly introduces us to different layers like Service layer, Validation layer, Repository layer as we go along from one chapter to another. In between the author introduces the MVC way of programming and how it differs from the WebForms way of programming - but assumes the reader already is aware of MVC as not much time is spent explaining MVC as this is a book more about TDD than MVC. (You can read different books which do a much better job of introducing to MVC than this one)

The book shows enough coding to make the reader understand what is going on (kind of gives the big picture) - but I would recommend that the reader download the sources (the author provides a link where you can download the source) and look to get finer details. The author makes sure that he is using MbUnit which is freely available for his unit test - though he briefly explains the other choices one could use.

The system the author is trying to develop is a message creation web site which has contact management and the ability to send emails to multiple contacts. The system has both client side validation (using Javascript library JQuery) and server side validation (using validation layer). The author explains how even if the client side validation is disabled the server side takes care of validation.

I would recommend this book if you don't know what TDD is and how to get started on it.

PROS : Flow is simple to understand what is happening.

CONS : A separate appendix explaining about the individual tools used would have given a much better reader experience.

I'm not really sure what other reviewers were looking at when they rated this book, but a book with code errors makes me cringe. They are just not acceptable. Period! You can have a few typos a few out of place words, but errors in code reflect very poorly on the book. That is one of my first problems with this book. A bigger problem is the way things are explained in this book. The author doesn't offer solid reasons for many things he did in this book starting with his choice of tools. If you are going to use a tool, explain your rationale completely so that people can make an informed choice. That is a small gripe because we all have tools that we like to use. The major problem is that you simply can't follow along with this book. The author will present a piece of code in the book. You, being the developer you are, try to follow along with that code. Your code doesn't compile. Why? Well it might be because the author is using something in HIS version of the code that you haven't built yet AND he doesn't tell you that. So what do you do? Well you look at the version of the code that came with the book and guess what? Errors! Maybe it is just me, but I think that of all the parts of a programming book that SHOULD be correct, the code stays solidly at number 1. You can skip over sections of the book that don't make sense, but if the code is wrong you can't reverse engineer it to understand what the author did. I think this book is simply inadequate and I feel really bad about that because I wanted this to be a good book. Wrox usually delivers, but not this time.