Book review – ASP.NET MVC in Action

ASP.Net MVC in Action

As some of you know, I’m not a web developer. I had a short affair with webforms, which ended… quickly leaving bad taste in my mouth. However it’s hard to ignore positive buzz around Microsoft’s “other” framework for building web applications – namely ASP.NET MVC. Especially it’s hard to ignore that the buzz comes from people I know, respect and hope they know what they’re talking about. I was quite happy to see that some of these people wrote a book about this framework so I decided to pick it up. I was expecting a great book, and a great book I got.

ASP.NET MVC in Action, judging from the title has a clear purpose – bringing you up to speed with the said framework. Most ‘framework’ (or language) books take an easy approach to the task – you get basically annotated specification with few better or worse samples and you’re left with figuring out (based on your own mistakes most of the time), which elements to use, and which not, how to use the framework/language in broader context of application and how to leverage its strengths to build testable, maintainable application that you ship and hopefully make money on. So is this book like that – no, and that’s its single greatest feature.

While the book does a good job at teaching you how to use the framework, it’s as much about the framework as about principles. I didn’t count but in the first chapter alone, I think word ‘testable’ appears more time than the word ‘MVC’. You get to learn about maintainability as much as about view helpers, onion architecture, as much as about controller actions… I think you get the idea.

But wait – there’s more. ASP.NET MVC is not a lonely island, it enters an existing (and growing) ecosystem of other tools and frameworks. The authors acknowledge that fact, and take full advantage of it. As as result of that you’ll learn as much about the framework’s API, as about how to plug it with extending projects (MVCContrib) how to use it in conjunction with IoC containers, persistence frameworks etc. All that while still keeping an eye on maintainability and proven practices. And to help you choose wisely, it contains an entire chapters dedicated to direct competitors of ASP.NET MVC – Castle Monorail, and Ruby on Rails.

While no book can make you a better developer by itself, they can be a great help in pointing you into right directions, guiding you to avoid pitfalls and common mistakes, and this by all means is such a book.

Book review – The Seed of Hope

The Seed of Hope (Talent Tree)

I used to be a big fan of fantasy and science fiction books back in a day. I read a ton of books by David Eddings, Mercedes Lackey, R. A. Salvatore, Janusz A. Zajdel and countless other authors. I’m still completing my collection of Discworld books, and trying to find some time to read the monstrous (1000+ pages) Lód by Jacek Dukaj. When Pragmatic Bookshelf released their first non-technical book, “The Seed of Hope”, I thought it might be an interesting venture – fantasy book by technical publisher.

We get quite a standard story, variations of which I’ve seen many times, so if you’re expecting some revolutionary plot… there isn’t any. We get the variation of an usual tale of an orphan child going on a trip to unveil its destiny and save the world along the way with the small help of some friends and their magical talents that they learn as they go.

That in itself is not a downside by any means, the whole Belgariad saga (five books, 500+ pages each)  are basically following the same idea, with Malloreon (yet 5 more books) reiterating it once again, and I had a blast reading them, although it was close to ten years ago.

I didn’t have a lot of fun reading The Seed of Hope though. First of all, the book is short – less than 300 pages, and it feels like a 700 pages book stripped of content to fit on the limited number of pages. This in turns forced the author to take a lot of shortcuts, not go into a lot of details, and as a result of that – the whole story feels flat. The world is pale, the characters shallow, and the storytelling just scratches the surface of the potential of the world. We don’t get to know the characters well enough to really understand their motivations, and their actions often felt random to me. The big story turning point when good characters crosses to the dark side felt naive for that very reason.

So we end up with a mediocre book. Not a bad one, as it has all the required parts, but the execution leaves a lot to be desired. I think especially younger readers will find it worthwhile. On the bright side, it motivated me to pick up that Carpe Jugulum, that I’ve been meaning to read for quite some time.

Book review – Debug It!: Find, Repair, and Prevent Bugs in Your Code


I bought Release it! some time ago, and it was a really good book. Now Pragmatic Programmer released a new book in their ‘do it!’ series – Debug it!, so when I got a change to snap a copy, I did, and I’m here to let you know that it is a remarkable book.

First of all, I think the title might be a little misleading for some people. It is about debugging in a broader sense than most people define it. If for you debugging equates dealing with debugger, you won’t find much of that in this book. The book talks about debugging as in getting the bugs out of your software (and doing your best to make sure they won’t come back).

The book is divided into three parts:

The first part, which accounts for almost half of the book, talks in great detail about four stages of dealing with bugs in your code – reproduction, diagnostics, actual fix and reflecting over reasons why the bug was there in the first place. There is not much earth shattering here, and when reading this part you’ll (hopefully) think to yourself – “yeah, I knew this” and “sure, it makes perfect sense”. The fact that this all common sense, and rules of thumb are gathered in one place though, and backed up by concrete discussion and good anecdotes helps you organize your workflow when dealing with misbehaving code. The fact that what you felt under your skin is said out loud makes you stop and realize there’s deeper meaning to all this.

Second part is relatively small, but concentrates on very important topic – working with people. That includes both, working with QA department and users as well as working with bug tracking systems. It discusses what makes a good bug report, what it should contain, what it should not contain etc. This part was a revelation, and if I could I would make it mandatory to read for all my clients, and people submitting bugs to OSS projects I contribute to. Then it moves to pragmatic approach towards working with bugs (hey, it’s a Pragmatic Bookshelf book after all). It talks about perfectionist attitude of bug-free software, and working with software that is riddled with bugs, which was interesting to read in the context of Tim’s post.

The final part, is a loosely connected group of topics, though it is as valuable as the previous ones. It talks about special cases, like service releases, about building the ideal debugging environment, which I found particularly interesting as this is topic close to my heart, although I would disagree with the author, who discourages extensive use of branching is source control. We also get a chapter on how to make software easy to debug. The book ends with list of anti-patterns along with discussion about how to remedy them.

I know that this book influenced the way I work now, and there aren’t many books I could say something like this about. It discusses extremely important part of software engineer’s profession, and does it very well. If you call yourself a pragmatic programmer I think you should read this book.

Technorati Tags: ,

Book review – C# in Depth, 2nd edition

Note, that this is a review of very early MEAP release – this is not complete book, and I review only 2 chapters that are available at the time of this writing.


If you are at least a casual user of StackOverflow you know who Jon Skeet is. Jon has a hard earned reputation of being an expert in just about anything he touches, so it came as no surprise that first edition of his C# in Depth book was universally praised for its high quality.

Fast forward almost 2 years later, we’re awaiting new version of .NET framework, along with its tools (Visual Studio) and what’s more important – new version of C# language. So while some of us are cheering for the new features and scenarios that new improvements enable we’re all faced with a task of upgrading our knowledge with this information. Here’s where Jon comes to the rescue with second edition of the book.

So far two chapters are available, both covering new additions to C# 4.0. “Minor changes to simplify code” talks about optional parameters, named arguments, COM improvements and generic variance. “Dynamic binding in a static language” is all about the dynamic keyword and all the things around it. The whole book however is going to talk about improvements introduced in earlier versions as well, and how they fit together in the grand scheme of things.

This is a language book, and language books tend to be either focused on a newcomer to the language, or try to satisfy both newcomers as well as people with experience which results in tomes of monstrous sizes. If you’re concerned that this is the case with this book – rest assured. This book is “lean and mean” – it does not waste your time explaining basic principles that would make you yawn or skip pages. It’s also very focused and concentrated on getting you up to speed with new features. It is really very well balanced in that it spends just enough time for you to grasp the feature, and then move on to the next one.  The only place where I felt lost was generic variance and higher order functions, but this is very convoluted stuff, so it’s not a downside by any means.

The book not only describes features from a bystander’s perspective, but is full of opinions and tips about them, which is arguably the best aspect of this book, and something that differentiate it from MSDN documentation or language specification.

That’s the great value of this book – it’s incredibly well written, and after you’ve read it, you feel like you not only know what the new features are – you also feel like you know how to put them into good use, how they work under the cover, what are their limitations, and how you might go about overcoming few of them. If you’re looking for a quick way of getting up to speed with C#’s fast progress, search no more – this is the book for you. Highly recommended.