I have previously written about how I learned ASP.NET MVC. It was primarily hands on learning but I did read a couple of ASP.NET MVC books along the way. The books I read dedicated a chapter or two to TDD and they certainly addressed the benefits of TDD and how MVC was designed with testability in mind, but TDD was merely an afterthought compared to, well, teaching one how to code the model, view and controller. This approach made some sense, and I learned a bunch about MVC from those books, but when it came to TDD the books were just a teaser and an opportunity missed.  But then I got lucky – Jonathan McCracken contacted me and asked if I’d review his book, Test-Drive ASP.NET MVC, and it was just what I needed to get over the TDD hump.

As the title suggests, Test-Drive ASP.NET MVC takes a different approach to learning MVC as it focuses on testing right from the very start. McCracken wastes no time and swiftly familiarizes us with the framework by building out a trivial Quote-O-Matic application and then dedicates the better part of his book to testing first – first by explaining TDD and then coding a full-featured Getting Organized application inspired by David Allen’s popular book, Getting Things Done. If you are a learn-by-example kind of coder (like me), you will instantly appreciate and enjoy McCracken’s style – its fast-moving, pragmatic and focused on only the most relevant information required to get you going with ASP.NET MVC and TDD.

The book continues with the test-first theme but McCracken moves away from the sample application and incorporates other practical skills like persisting models with NHibernate, leveraging Inversion of Control with the IControllerFactory and building a RESTful web service. What I most appreciated about this section was McCracken’s use of and praise for open source libraries like Rhino Mocks, SQLite and StructureMap (to name just a few) and productivity tools like ReSharper, Web Platform Installer and ASP.NET SQL Server Setup Wizard.  McCracken’s emphasis on real world, pragmatic development was clearly demonstrated in every tool choice, straight-forward code block and developer tip. Whether one is already familiar with the tools/tips or not, McCracken’s thought process is easily understood and appreciated.

The final section of the book walks the reader through security and deployment – everything from error handling and logging with ELMAH, to ASP.NET Health Monitoring, to using MSBuild with automated builds, to the deployment  of ASP.NET MVC to various web environments. These chapters, like those prior, offer enough information and explanation to simply help you get the job done. 

Do I believe Test-Drive ASP.NET MVC will turn you into an expert MVC developer overnight?  Well, no.  I don’t think any book can make that claim.  If that were possible, I think book list prices would skyrocket!  That said, Test-Drive ASP.NET MVC provides a solid foundation and a unique (and dare I say necessary) approach to learning ASP.NET MVC.  Along the way McCracken shares loads of very practical software development tips and references numerous tools and libraries. The bottom line is it’s a great ASP.NET MVC primer – if you’re new to ASP.NET MVC it’s just what you need to get started. 

Do I believe Test-Drive ASP.NET MVC will give you everything you need to start employing TDD in your everyday development?  Well, I used to think that learning TDD required a lot of practice and, if you’re lucky enough, the guidance of a mentor or coach.  I used to think that one couldn’t learn TDD from a book alone. Well, I’m still no pro, but I’m testing first now and Jonathan McCracken and his book, Test-Drive ASP.NET MVC, played a big part in making this happen.  If you are an MVC developer and a TDD newb, Test-Drive ASP.NET MVC is just the book for you.

I have told this story before but early in my career, when I wanted to learn a new technology, I’d sit on the floor in the bookstore aisle and work my way through each of the available books on a given subject.  Put in enough time in a bookstore and you can learn just about anything. I used to really enjoy this time but over the years my habits have certainly changed.  Whereas books used to be the only place I could find solutions to my problems, now they may be the very last place I look. Case in point, it wasn’t until I had worked with the ASP.NET MVC 1.0 Framework for more than a year, and I had a few projects and a couple of major deployments under my belt, did I finally read through Steven Sanderson’s Pro ASP.NET MVC Framework. With so many resources at my fingertips (podcasts, screen casts, blogs, stackoverflow, open source projects, www.asp.net) I was able to get up to speed with ASP.NET MVC without reading a single book.  So, I didn’t until late into the game.  

This past April, the day after the RTM release became available, I upgraded my primary MVC project to MVC 2.  Now, a few months later, there are a handful of MVC 2 books on the shelves of those said bookstores and I now offer you a review of Professional ASP.NET MVC 2.  You may know that I have given a lot of praise to Sanderson’s first book so why did I choose Professional ASP.NET MVC 2 over the second edition of Sanderson’s book? Well, the NerdDinner chapter (a.k.a the free bits) of Professional ASP.NET MVC 1.0 offered me a really great MVC primer but I never got around to buying the book.  Not only has the guilt weighed on me a bit, it’s also been quite the cliffhanger.  Having now read through the second edition of Professional ASP.NET MVC 2, I now know that everything worked out for Guthrie, Hanselman, Haack, Conery but I’ve been worried.  (Sorry if I just spoiled the ending for you.)  Anything else?  Yes. Full disclosure, a copy of Professional ASP.NET MVC 2 kind of fell in my lap as Jon gave me a copy on my birthday. He didn’t know it was my big day but it was.  And this leads us into the first thing you’ll undoubtedly notice about the book – there is one more author, Jon Galloway, and the four foreheads on the book cover have been replaced by a blurry bobsled.  Welcome change all around, I think.

As you may have guessed, Professional ASP.NET MVC 2 begins with a new and improved NerdDinner walkthrough. With the book’s first release, I coded up the application from scratch as I followed along, step by step, with the tutorial. I even uncovered and fixed a couple of bugs, but don’t tell.  This new NerdDinner tutorial does a fine job of working in a number features which were introduced with MVC 2.  That’s stuff like HTML Encoding Code Blocks, Strongly Typed HTML Helpers, Templated Helpers, and Client-Side Validation.  There are other new features, and we’ll get to those. If you can get through the tutorial and understand what MVC has to offer, congratulations, you now know enough to be dangerous. But should you stop there? Does the NerdDinner sample application provide you everything you need to become a full-fledged MVC developer?  You might think so, but nope, not even close.  Thus, there’s a lot more book to give you the rest of the scoop.  Think of the NerdDinner sample as the appetizer which whets your appetite, leaving you craving for the main course.  Sorry, I couldn’t help myself…

With that, onto the rest of the book review:

Chapter 2 shares the history of the MVC design pattern and runs through other popular MVC web frameworks you may have seen running in the wild. This chapter also brings attention to the “how” and “why” ASP.NET MVC came into existence. Chapter 3 builds on these same points and explores ASP.NET MVC basics like separation of concerns, maintainability and testability and how ASP.NET MVC relates to both WebForms and ASP.NET as a whole.  You might be thinking, “That’s great but is this going to make me a better MVC developer?”  I was tempted to say that these two chapters aren’t required reading unless you are a complete MVC newbie, but the truth is there’s always value in learning about the background of a technology, pattern, language or framework in order to better understand and master it.  And knowing this information will separate those passionate about MVC from those who merely code against MVC.  So, yes, these chapters will make you a better developer.

Chapter 4 digs into routing and sheds light on a number of sophisticated scenarios. If you have a good handle on routing from your work with MVC 1, you will acknowledge the chapter as being well-written but nothing new is going to jump off the page at you.  However, if you are new to  MVC, you need a strong understanding of outgoing and incoming routes, route patterns and how possible gotchas like Overflow Parameters work and this book does a wonderful job explaining these concepts.  And don’t forget that routing is now exposed in the ASP.NET libraries to be used in WebForms too.  You know, just in case MVC isn’t your cup of tea.

Chapter 5 and 6 dive into controllers and views, respectively.  If you’re new to MVC, the authors walk you through everything you’ll need to know about the C and V in MVC.  For those focusing on the MVC 2 bits, there’s a very nice overview of how requests are handled on the server along with an explanation of how to benefit from the new Asynchronous Controller Actions.  You may have picked up a lot about what views have to offer from the NerdDinner tutorial already but you’d be surprised what else you’ll pick up from this detailed chapter.  Again, for those honing in on MVC 2, give special attention to the new Html.Action and Html.RenderAction helper methods.  Final note on views – I commend the authors for including a rundown of the most popular alternative view engines.  Pretty classy.  On aside, since we’re talking about the V and the C, there isn’t a chapter dedicated to the M, models.  The NerdDinner walkthrough may have sufficiently covered this topic, but the topic was otherwise absent.

Chapter 7 is focused on Ajax, partials and jQuery.  This section is somewhat like a cookbook with lots of recipes.  It’s a little different than the rest of the book as it offers more code examples than written explanation of what the AJAX and jQuery libraries bring to the MVC 2 table. Having worked with MVC for a while now, it’s apparent from Day 1 of development that one needs to have their Ajax and Javascript/jQuery hat on if they want to work with effectively with the framework.  Thankfully Chapter 7 offers a surfeit of practical examples.  Be sure to bookmark this section because you’ll be referring back to it when you need a ratings or autocomplete textbox implementation.

Chapter 8 shows us how one can use Filters to add behavior to action methods.  For the MVC neophytes, filters are powerful.  Soak this chapter in.  For the MVC veterans, be on the look out for the RequireHttps action filter which was introduced with MVC 2. 

Chapter 9 speaks to securing our MVC applications.  I agree with the authors – this should be required reading.  This chapter uses case studies, quotes, short stories, humor, scare tactics, anything and everything to get important points across to the reader.  Listen, security is important.  If you’re a WebForms convert, read carefully as MVC doesn’t hold your hand quite as much as the WebForms world does when it comes to securing your application.  And give thanks to the authors for their willingness to talk about security concerns throughout the book as well dedicate an entire chapter to this topic.  This chapter also includes number of additional reading references which might be worth your time.

Chapter 10 and 11 are dedicated to TDD, unit testing and testable design patterns. The book provides a nice introduction into these topics and solid foundation on how to get started with these design/testing techniques.  Professional ASP.NET MVC 2 includes more than 50 pages of TDD/testing instruction.  Truly, one of the greatest benefits of ASP.NET MVC is testability and if you are new to testing, this book will be a wonderful jumping off point for you.

I’m a bad person. I didn’t read Chapter 12, Best of Both Worlds: Web Forms and MVC Together. I skimmed through it but that’s it.  Obviously there’s demand for this information or it wouldn’t be included in the book but mixing WebForms and MVC doesn’t pertain to me right now. Maybe I’m being shortsighted but I’d like to keep these worlds separate for now. If there comes a time and I need to migrate a WebForms app to MVC, I’ll be sure to come back to this chapter.  For now, it remains unread. Sorry.

Remember how the NerdDinner tutorial sample showed off a number of the new ASP.NET MVC 2 features?  Well, it didn’t catch them all.  That’s where Chapter 13 comes in – offering a roll up of everything new to MVC.  You may actually want to read this chapter first just to become acquainted with the new bits.  That way you can be sure to pick up on the callouts elsewhere in the book.  A couple of important notes – you will find details about Areas in Chapter 13 which you won’t find in any other section. Also there’s an important note about breaking changes with JsonResult when upgrading from MVC 1 to 2.  The change is web vulnerability related and don’t say I didn’t warn you.

A few additional notes about the book which I couldn’t find a good place for elsewhere:

• Comments from the ASP.NET Product Team are inserted throughout the book. These tips and additional info were my favorite part of the book.  It’s kind of like VH1’s “Behind the Music” to me
• My only real concern with the NerdDinner tutorial is the emphasis placed on the Entity Framework (EF).  When the original tutorial was published, I encouraged everyone on my team to work through the sample application before diving into their first MVC project.  One of my colleagues was so impressed with MVC that they presented what they learned to the rest of the team.  Guess the name of the presentation. It was “An Overview of the .NET MVC Entity Framework.”  Yikes! In the individual’s defense, they had no prior experience with the .NET stack and frankly the Professional ASP.NET MVC book does drive home the concept of building out one’s model with EF.  There is quick mention of other ORMs which can be used with ASP.NET MVC, but guess which path someone new to .NET will follow?  I don’t feel the use of the Entity Framework is inappropriate in the NerdDinner sample, but I do think it is important to stress (yes, a little more) that EF is not part of the MVC framework and maybe even offer hints as to how one might hook in another ORM if they so choose. This said, I suppose I have the same issue with the references to ASP.NET Forms Authentication, ASP.NET Membership and Role Management APIs, not to mention the Visual Studio Unit Test framework.  [Disclaimer: I am using EF4 and the ASP.NET Membership stuff on my primary project and I think they are both the bees knees.]
• If you are turning to MVC in hopes to never hear or read about WebForms again, you’re kind of out of luck because Professional ASP.NET MVC offers lots of WebForms commentary.  If you are only interested in MVC, this constant reminder of  WebForms might be a little distracting.
• In the NerdDinner sample, data-type validation was implemented using DataAnnotations.  DataAnnotations are fine, but I would have liked to read more about validating true business rules (e.g. ensuring passwords are strong, validating a shipping date doesn’t fall on a weekend or holiday, or guaranteeing a submitted email address is unique). Managing this type of validation can be complicated and this topic was glossed over entirely.
• Your Professional ASP.NET MVC 2 purchase comes with two weeks of TekPub access. You may wish to factor this in when your calculating the true purchase price.

As I alluded to earlier, you may be tempted to read through the NerdDinner tutorial and then go off and code up a storm. Don’t do it! The rest of the book has so much to offer – especially to someone brand new to ASP.NET MVC.  Really, soak up what’s provided in all of the chapters.  And as I climb onto my soapbox, please remember that sample applications like NerdDinner demonstrate basic and generalized implementations in order to highlight new features and ensure focus is firmly set on teaching and learning specific information.  If you wish to really understand ASP.NET MVC 2 development, work through the NerdDinner tutorial, read Professional ASP.NET MVC 2 cover to cover, write lots of your own code, read lots of other people’s code, come up with your own ideas and keep learning from the many other resources which are readily available to you.  I recommend Professional ASP.NET MVC 2 – it’ll get you off to a great start.

I popped the disc into the console and in less than 2 minutes the brain-numbingly simple activation was complete.  (Full-disclosure: I already had my Wi-Fi connection configured, but I’m confident that the Netflix installation disc would have helpfully walked me through this additional step if need be.)

As it turns out, the Wii Netflix UI offers far more options than what one gets with the Blu-ray setup.  Not only can I view my Instant Queue, but there’s a list of recently watched movies, a list of recommended titles by category, the star rating system, movies information and nearly everything you find on the web. 

I reread Steve Krug’s Don’t Make Me Think: A Common Sense Approach to Web Usability on a flight back from Orlando on Wednesday, so my current view of the world may be a little skewed but, the brilliance of Netflix Wii’s user interface is undeniable. It’s not like the Blu-ray navigation is complicated but the Wii navigation feels familiar and intuitive. How intuitive?  Well, you won’t find a single bit of help text on any of the Wii screens – just a simple and obvious point-and-click navigation system.  And the UI is really pretty (which is still very important if you ask me) and so easy it became fun.

Did I mention the media streaming works!  Yep, we watched 2 half-hour kid videos yesterday without any streaming issues at all.  If you have a Netflix account and a Wii, order your disc and give it a go. It’s good stuff.

I have been working with the ASP.NET MVC Framework for more than a year.  I have a few projects and a couple of major deployments under my belt and I was able to get up to speed with the framework without reading a single book*.  With so many resources at our fingertips (podcasts, screencasts, blogs, stackoverflow, open source projects, www.asp.net, you name it) why bother with a book?

Well, I flipped through Steven Sanderson’s Pro ASP.NET MVC Framework a few months ago. And since it is prominently displayed in my co-worker’s office, I tend to pick it up as a reference from time to time.  Last week, I’m not sure why, I decided to read it cover to cover.  Man, did I eat this book up.  Granted, a lot of what I read was review, but it was only review because I had already learned lessons by piecing the puzzle together for myself via various sources.

If I were starting with ASP.NET MVC (or ASP.NET Web Deployment in general) today, the first thing I would do is buy Steven Sanderson’s Pro ASP.NET MVC Framework and read it cover to cover.

Steven Sanderson did such a great job with this book! As much as I appreciated the in-depth model, view, and controller talk, I was completely impressed with all the extra bits which were included.  There a was nice overview of BDD, view engine comparisons, a chapter dedicated to security and vulnerabilities, IoC, TDD and Mocking (of course), IIS deployment options and a nice overview of what the .NET platform and C# offers.  Heck, Sanderson even include bits about webforms!

The book is fantastic and I highly recommend it – even if you think you’ve already got your head around ASP.NET MVC.  By the way, procrastinators may be in luck.  ASP.NET MVC V2 Framework can be pre-ordered.  You might want to jump right into the second edition and find out what Sanderson has to say about MVC 2.

* Actually, I did read through the free bits of Professional ASP.NET MVC 1.0.  But it was just a chapter – albeit a really long chapter.

The BDP-N460 allows you to instantly stream thousands of movies, videos and music from the largest selection of leading content providers including Netflix, Amazon Video On Demand, YouTube^™, Slacker^® Radio and many, many more. Plus, enjoy the ultimate in high-definition entertainment and watch Blu-ray Disc movies in Full HD 1080p quality with HD audio.

The BDP-N460 includes built-in software that makes it easy to connect this player to your existing wireless network.  So I did… I paired the disc player with the recommended Linksys Wireless Ethernet Bridge (WET-610N) and I was streaming the last season of Lost episodes in no time.

Really cool. Highly recommended.

Atif Aziz provided a quick solution in his answer to a Stack Overflow question.  I’ll let you consult his answer to see how one can subclass the HandleErrorAttribute and override the OnException method in order to get the bits working.  I pretty much took rolled the recommended logic into my application and it worked like a charm. 

Along the way, I did uncover a few HandleError fact to which I wasn’t already privy.  Most of my learning came from Steven Sanderson’s book, Pro ASP.NET MVC Framework.  I’ve flipped through a bunch of the book and spent time on specific sections.  It’s a really good read if you’re looking to pick up an ASP.NET MVC reference.

Anyway, my notes are found a comments in the following code snippet.  I hope my notes clarify a few things for you too.

Balsamiq mockups sped up my document writing time. It also increased the overall document quality and understandability when it came to sharing ideas with my customer.  Of course, the fact that working with Balsamiq Mockups is just plain fun doesn’t hurt my opinion of the tool…

The biggest plus is the fact the mockup data – even the data which is generated using the online trial – is yours and it’s in an open, portable and human readable format.  In other words, it’s super easy to duplicate, edit and share mockups.

If you want to learn more about Balsamiq Mockups, check out the product page.  Otherwise, just give it a try.  I promise it will be fun (and maybe even productive.)

Page 3 – Way more than I ever wanted to know about the CLR’s execution model.  That is, everything about Managed Modules, Assemblies, Intermediate Language (IL), Framework Class Library (FCL), Common Type System (CTS) and Common Language Specification (CLS.) 

Page 56 – How to properly version your assemblies – including a breakdown of the assembly version resource information, how/when to increment the major, minor, build and revision numbers, and the distinction between AssemblyFileVersion, AssemblyInfomationVersion and AssemblyVersion numbers.

Page 144 – Best practices on how to write code to compare objects.  Here, Richter drills into object equality, identity and hash codes.

Page 177 – How the compiler handles constants – their values are embedded inside the IL code at compile time. 

Page 185 – Why one must beware of code explosion with initializing fields within classes with multiple constructors.  Key points: Any fields that the constructor doesn’t explicitly overwrite are guaranteed to have a value of 0 or null.  The compiler embeds, at the beginning of all constructor methods, field initialization code.  You should consider not initializing the default field value at the point of field declaration and instead perform the common initialization in a single constructor and have all other constructors explicitly call the common initialization constructor before overriding varying defaults. 

internal sealed class SomeType
{
    // Do not explicitly initialize the fields here
    private Int32 x;
    private String y;
    private Double z;

    // Sets all fields to their default
    // All constructors explicitly invoke this constructor
    public SomeType()
    {
        x = 5;
        y = "Ben";
        z = 3.14159;
    }

    // Sets all fields to their default, then changes x
    public SomeType(Int32 x) : this()
    {
        this.x = x;
    }

    // Sets all fields to their default, then changes y
    public SomeType(String y) : this()
    {
        this.y = y;
    }

    // Sets all fields to their default, then changes x, y
    public SomeType(Int32 x, String y) : this()
    {
        this.x = x;
        this.y = y;
    }
}

Page 254 – The power of string interning and string  pooling.

Page 309 – How to perform unsafe array access and fixed-sized arrays.

Page 322 – How to implement multiple interfaces that have the same method name and signature and…

Page 325 – Why you need to be really careful when using explicit interface method implementations.

Page 365 – A quick introduction into Wintellect’s Power Collections library which extends the .NET Framework’s Class Library with an assortment of collection classes. The Power Collections library, documentation, and licensing information is available on CodePlex.

Page 411 – How the CLR provides special support for Nullable value types.

Page 431 – A little background on System.Exception, System.SystemException and System.ApplicationException and how Microsoft through the basic principles out the window.

Page 457 – Way more information than any single person should know about Garbage Collection (GC).

Page 562 – How to build a system which support add-ins.

Though it wasn’t mentioned in the book, Richter’s Power Threading library (DLL) contains many classes to help with threading and asynchronous programming for the .NET Framework, Silverlight, and the .NET Compact Framework. Jeffrey has described many of the classes contained in the library by way of his MSDN Magazine Concurrent Affairs columns and I found his Channel 9 overview on the AsyncEnumerator class (which uses Yield to simplify multithreading) absolutely fascinating.  The Power Threading Library is available for download here.

That’s fifteen.  I should probably drill into a couple of these with code samples…or you could just get a copy of the book.

Random closing thought: When I was flipping through the book today I found a spider smashed between pages 72 and 73.  Ironic?

Okay. Now what is FlexBox exactly?

It is a dynamic control which can present itself as a combobox with per-result HTML templates, a suggest box (like Google search) or a data-driven type-ahead input box.  It supports theming/skinning via CSS, flexible paging, configurable client-side cache and much more. 

Great.  We got it.  It’s clearly flexible, but is it easy to use? 

Yes.  It’s also super easy to use. 

Prove it!

Okay, for example, you can generate a Google Suggests-type textbox in just a few steps:

1. Reference jQuery and the FlexBox scripts.
2. Add an empty div to the <body> tag wherever you want the FlexBox to appear.
3. And assuming results.aspx returns JSON data and your div has an id = “ffb3″, this code will render a suggest box similar to that represented in the image to the right:

   $('#ffb3').flexbox('results.aspx', {
       showArrow: false
   });

Pretty slick, eh?  FlexBox was developed by a co-worker of mine, Noah Heldman, as an open source project hosted on CodePlex. It is well documented (including a Getting Started Guide) and comes along with a great demo page.  I think Noah did a really nice job with this plugin.  If you’re looking for a searchable textbox/dropdown, I suggest you check it out.

FlexBox CodePlex Project Page
FlexBox jQuery Plugin Page
FlexBox Overview

If you are an experienced JavaScript developer (i.e. your JS code does more than trigger alerts, toggle divs and set window locations), you know the language is not particularly easy to get your head around.  In my opinion, most web developers have a poor understanding of JavaScript to the extent that the bulk of their JS code (mine included) is a mere collection of hacked-together, simple statements.  Based on my judgement, the appendix title should read “JavaScript that you need to know but you more than likely do not!” 

Generously, “jQuery in Action” provides a thorough overview of “basic” JS concepts like objects and JSON, functions being first-class objects, controlling what “this” means along with closures.  I’ve really enjoyed jQuery in Action thus far – particularly because the authors ensure that their readers have a firm understanding of core JavaScript concepts which are arguably the necessary foundation to effectively use jQuery.

The next time you find yourself in your local bookstore, sit down in the aisle with a copy of “jQuery in Action” and give the appendix a good read.  It’s 19 pages of pure Javascript goodness.  And who knows?  You might even purchased the copy and read the jQuery parts…

It is worth noting that those of us in the .NET community are rather fortunate as there are a number of recent newcomers in this space.  In fact, four of my top six podcasts have been around for less than 4 months.  I personally think they’ve all done a standup job and it has been enjoyable listening to the podcasts as they mature.  Maybe some day, years from now, young developers will gather around as I tell tales of the very first Herding Code podcast. You never know…

Enough with the intro already.  Here’s my .NET Podcast Recommendation List in no particular order (other than alphabetical):

Alt.NET Podcast
http://altnetpodcast.com/
Hosted by Mike Moore
Currently on Episode 8 

Deep Fried Bytes
http://deepfriedbytes.com/
Hosted by Keith Elder and Chris Woodruff
Currently on Episode 8

Hanselminutes 
http://www.hanselminutes.com/
Hosted by Scott Hanselman
Currently on Show #124 

Herding Code
http://herdingcode.com/
Hosted by Jon Galloway, K. Scott Allen, Kevin Dente and Scott Koon
Currently on Episode 11

.NET Rocks!
http://www.dotnetrocks.com/
Hosted by Carl Franklin and Richard Campbell
Currently on Show #365

Stackoverflow
http://blog.stackoverflow.com/
Hosted by Jeff Atwood and Joel Spolsky
Currently on Podcast #16

• Windows Installer XML (WiX) Toolset is a Microsoft open source project used to create the Office 2007 installer. WiX includes some advanced capabilities, but it has a steep learning curve even though the scripting language is XML-based.
• NSIS (Nullsoft Scriptable Install System) is a professional open source system to create Windows installers. It is designed to be as small and flexible as possible and is therefore very suitable for Internet distribution. It has a rich feature list, a good set of online samples and a good community following.
• Inno Setup is another free, open source installer for Windows programs. First introduced in 1997, Inno Setup today rivals and even surpasses many commercial installers in feature set and stability.

Decision

After a quick review of each product, I opted to run with Inno Setup primarily because it had the ugliest website, all of their product award links are broken and it isn’t known by any acronym…yet.  Joking aside, I chose Jordan Russell’s Inno Setup because it met all of my requirements almost effortlessly.  Here’s the rundown of what I needed:

• Check for the .NET Framework and install if not found
• Check if Remote Registry is running and start if stopped.
• Check is UAC is enabled and provide user dialogue.
• Open website(s).
• Create quick launch, desktop, start icons.
• Read, update registry.
• Ask custom questions and manage response.
• Launch applications.
• Install silently.
• Create associated uninstaller.
• Show/acknowledge terms of service.
• Display readme.
• Customizable/skinnable display.  
• Etc

Additionally, Inno Setup it is such an easy tool to use and test and it has been around for a long while and has a great feature list:

• Support for all versions of Windows in use today: Vista, XP, 2008, 2003, 2000, Me, 98, 95, and NT 4.0. (No service packs are required.)
• Extensive support for installation of 64-bit applications on the 64-bit editions of Windows. Both the x64 and Itanium architectures are supported. (On the Itanium architecture, Service Pack 1 or later is required on Windows Server 2003 to install in 64-bit mode.)
• Supports creation of a single EXE to install your program for easy online distribution. Disk spanning is also supported.
• Standard Windows 2000/XP-style wizard interface.
• Customizable setup types, e.g. Full, Minimal, Custom.
• Complete uninstall capabilities.
• Installation of files:
  Includes integrated support for “deflate”, bzip2, and 7-Zip LZMA file compression. The installer has the ability to compare file version info, replace in-use files, use shared file counting, register DLL/OCX’s and type libraries, and install fonts.
• Creation of shortcuts anywhere, including in the Start Menu and on the desktop.
• Creation of registry and .INI entries.
• Integrated Pascal scripting engine.
• Support for multilingual installs.
• Support for passworded and encrypted installs.
• Silent install and uninstall.
• Full source code is available (Borland Delphi 2.0-5.0).

Oh, and have I mentioned that it is free? 

Getting Started

The basic installer includes the Inno Setup Compiler, documentation and numerous samples.  If you want to get started quickly just download Inno Setup and review the sample scripts.  You’ll be creating your own installers in no time.  Alternatively, you could download/install the QuickStart Pack, but I honestly do not think it is necessary.

As I mentioned, a review/compilation of the samples can provide a quick, easy introduction into the impressive tool. All the examples are worth a look, but I feel it is necessary to give a few special mention:

• Example1.iss, Example2.iss and Example3.iss provide a great foundation as they demonstrate how to access the registry, add a desktop icon, include a readme file, etc, etc, etc.  
• If you are planning to do anything non-standard, play around with the CodeExample1.iss sample.  It essentially builds a basic setup, captures every installer event, includes custom functions, and demonstrates how to extract/expand files, display dialogues and issue before and after installer actions. 
• Finally, if you want to build custom pages, check out CodeDlg.iss which demonstrates how to build installer pages with custom questions and user input options.

My suggestion is to review the samples from within the Compiler.  The Compiler doesn’t have intellisense or anything, but it will obviously validate your script and call out where invalid syntax exists.  The Compiler also allows you to immediately “run” your installer script (by clicking on the green arrow button) or compile the script (by clicking on the fourth button from the left.) What the heck is that anyway?  The Compile IDE is a fancy notepad with options and actions.  It’s simple and I dig it.

Speaking of simple, here’s an example script.  You would have to build on its foundation if you wanted to do anything fancy, like read from the registry, but these few lines practically do it all.  They copy three files into the Program Files sub directory, displays a read me file and add an icon to the Start Menu.  And all the standard installer pages (splash, location, completion, etc) comes along for free — free meaning no effort and no code.

[Setup]
AppName=My Program
AppVerName=My Program version 1.5
DefaultDirName={pf}\My Program
DefaultGroupName=My Program
UninstallDisplayIcon={app}\MyProg.exe
Compression=lzma
SolidCompression=yes
OutputDir=userdocs:Inno Setup Examples Output

[Files]
Source: “MyProg.exe”; DestDir: “{app}”
Source: “MyProg.chm”; DestDir: “{app}”
Source: “Readme.txt”; DestDir: “{app}”; Flags: isreadme

[Icons]
Name: “{group}\My Program”; Filename: “{app}\MyProg.exe”

Extra Help

Finding the right syntax wasn’t always a breeze as everything isn’t covered in the samples.  With that said, the best online reference I found was an Inno Setup Manual hosted at AgentSoft.com. I can’t say I know the connection between AgentSoft and Inno but I’m still very happy to have found the reference.  I also found various “real world” installer scripts, like this one, posted online which really helped facilitate my ramp up.

.NET Framework Install Script

In my requirements list, I called out the need to check for the .NET Framework and install if it wasn’t found.  This functionality is a snap using Inno Setup — just be sure to use the Client Profile version of the installer.

[Files]
Source: “Executables\dotnetfx35setup.exe”; DestDir: “{tmp}”; Flags: deleteafterinstall

[Run]
Filename: {tmp}\dotnetfx35setup.exe; Parameters: “/Q /NORESTART”; Check: Is35FrameworkInstalled; Flags: runhidden shellexec waituntilterminated; StatusMsg: “This may forever.”

[Code]
function Is35FrameworkInstalled():Boolean;
begin
    Result := not RegKeyExists(HKEY_LOCAL_MACHINE, ‘SOFTWARE\Microsoft\Net Framework Setup\NDP\v3.5′);
end;

Summary

I’ll keep it short and sweet: Inno Setup is one slick piece of software that made the dreaded task of creating a custom installer one heck of a lot easier than it could have been.  I’ve added Inno Setup to my toolbox and I highly suggest you do too.

But as slick as it is, TortoiseSVN requires one to bounce between their IDE and the Windows Explorer.  You’re right!  A simple, two-second step, a mere ALT-TAB, shouldn’t be that disruptive but, for me, it is and it keeps me from committing my changes as often as I probably should.  Perhaps this is a flaw in the way I work, but it is, without a doubt, the way I work.

There are two players in the “Subversion Source Control Provider for Visual Studio” space.  There’s VisualSVN and there’s AnkhSVN.   Until this week, I had heard nothing but good things about VisualSVN and AnkhSVN reviews weren’t nearly as favorable. 

I ended up trying VisualSVN for over a week and, frankly, I was disappointed. I deserve to get negative feedback about publishing the following comments without any supporting documentation but I found VisualSVN to be sluggish and I felt it called up TortoiseSVN dialogues (rather than handling the file management itself) far too often.  Since so many folks like the product, I would be willing to bet I simply had a very bad first go (although I did spend over 1 week with the product.) All the same, it is uninstalled, the $49 are still burning a hole in my pocket and, well, there was no harm done. 

I reverted to my old ways of not using source control effectively by avoiding Windows Explorer and TortoiseSVN and then, on my birthday, AnkhSVN 2.0 Final was released.  Though folks grumbled about the previous version, 2.0 is a near rewrite of the original and is now a full Source Control Provider Integration Package rather than a Visual Studio Add-In. With commercial backing from CollabNet and renewed open source enthusiasm, AnkhSVN 2.0 seemed to deserve a look so I looked…

Quick Start

1. Download AnkhSVN 2.0 here and run the install package.  If you want the latest and greatest, check out the daily builds. 

2. The AnkhSVN download page says to install and then “Start Visual Studio and choose Tools -> Settings -> Source Control and make sure AnkhSVN is the active source control provider.”  Actually, you want Tools -> Options rather than Settings, but you would probably figure that out on your own.  All the same, AnkhSVN was already configured/selected.

3. Open an existing solution and noticed the new “Pending Changes” windows (also available via View -> Show Pending Changes.)  Enter your repository URL into the empty “Working on:” field and, if you are as lucky as me (after all it was my birthday), everything should just work. 

4. This step is optional, but inevitable. I think. After about 20 minutes of playing with AnkhSVN you’re probably going to want to hook up your favorite diff tool.  If your favorite diff tool is WinMerge, perform the following: Go to Tools -> Options -> Source Control -> Subversion -> External Diff Path = “C:\Program Files\WinMerge\WinMergeU.exe” “%base” “%mine”

5. Once you are setup, you will see green check-marks alongside items in the Solution Explorer window.  And, as you start to make changes, you will see modified items added to the Pending Changes window.  This, my friends, is  a great feature!  Now you able to manage all of your changes in a single location rather than having to navigate through Windows Explorer or even the Solution Explorer. In another life, StarTeam provided me with similar functionality by allowing me to flatten out the folder hierarchy and then sorting by status, but the Pending Changes windows is 100 times better.  Sure, you can manage your commits via the Solution Explorer, but I’m not going to. The Pending Changes view is also great since the Solution Explorer doesn’t always conveniently show you the status of your files.  Take the screen shot below, for example.  Collapsing the EmailTemplates folder leaves me no insight into the state of the files within.  (For the record, I prefer VisualSVN’s Solution Explorer display.)

Side note: If I could do it all over again, I really wish I followed the posted download instructions.  The suggested setup sounds straight forward enough, but trying to replicate the steps now, after already setting up, is seemingly impossible.  The instructions can be firmed up for clarity (see prior example referring to incorrect menu names), but I would have liked to give them a test run without jumping the gun and setting up my own way first.  If you do follow the published install instructions, let me know how it goes for you as I simply can not make heads or tails out of some of the steps.  One thing which seems to be missing — perhaps because of my impatience — is the persistence of the Subversion repositories added to the Repository Explorer.  It is really nice a version of the Repository Browser is built in, but it seems odd that repositories would need to be reestablished each time you open a solution.  Anyhow, it is probably my fault…

Wrap Up

Thus far, I am pleased with AnkhSVN.  For those of you who tried out earlier versions and were disappointed, try again.  Here’s a partial list of what’s new in AnkhSVN 2.0:

• For Microsoft Visual Studio 2005 and 2008.
• Built on Subversion 1.5.0 via SharpSvn.
• Pending changes window; subversion status and commands available in one place
• Full support for Visual Studio 2005 and 2008; AnkhSVN is now a SCC package instead of just an addin
• Better log viewer
• Merge support
• Property editor
• AnkhSVN now supports most project types previously unsupported via the SCC api
• All solution explorer actions (rename, copy&paste, drag&drop) keep subversion history now
• Enhanced build process and setup
• Automatic check for updates
• And last but certainly not least end user documentation

For more information about AnkhSVN, check out the project’s home.

After launching VS2008, R# 4.0 Beta asked me a couple configuration-preference-type questions and then I completely stomped on my code until I could recognize it no more.  (Did I mention the full source tree was already committed to source control?)  

I played with R# for well over an hour as anonymous delegates became lambda expressions¹, object instantiation plus a number of property sets were rolled up into an object initializer², if statements were inverted, switches became if-else statements, foreachs became to-fors, unused methods were removed, ternary operators were introduced, classes were moved into new files, namespaces were updated and on and on and on and back again.

I know I’ve only brushed the surfaces of what R# can do (3.1 feature list, 4.0 beta feature list,) but knowing R# offers far more than a ridiculous number of refactoring shortcuts, I can’t hardly wait to start using it as I write new code. 

One might consider this recommendation premature, but I encourage you to give ReSharper 4.0 Beta a whirl especially if you are new to Visual Studio 2008 and C# 3.* since R# essentially provides you with a painless primer.  (Can’t get your head around Lambdas?  ReSharper 4.0 will create such an expression for you.) It is a quick download and install and it takes only a few minutes to feel the power of the ALT+ENTER keystroke. 

I hope the Add-in makes coding fun enough to make you giggle.

Example Refactor 1

private bool IsAliased()
{
    var computer = computerList.Find(delegate(Computer c)
        { return c.ID == RegistryHelper.MachineID; });
    return (computer.Name != computer.Alias);
}

became

private bool IsAliased()
{
    var computer = computerList.Find(c => c.ID == RegistryHelper.MachineID);
    return (computer.Name != computer.Alias);
}

Example Refactor 2

Notification notification = new Notification();
notification.Message = "Message 1";
notification.Title= true;

became

Notification notification =
    new Notification { Message = "Message 1", Title = true };

I know that last statement sounds funny but put yourself in the position of my customer.  They currently have a working product which they wish to extend and private label.  With the core functionality already in place (read: tested with dozens if not hundreds of users,) how much time could/should it take to implement my updates?

While ramping up, I jotted down a number of areas where the application could be improved but I tabled every task which wouldn’t get me closer to completing my assignment.  In other words, if the change was transparent to my client, I didn’t muck with it — for the most part.

Which brings me to this morning, approximately two weeks into my development, and my uneasy feeling.  The bottom-line is I made the wrong call.  I should have made the product my own, so to speak, and applied a handful of design changes right off the bat.  If I were completing a simple bug fix, this approach would have been wrong, but since I am scheduled for appropriately 2 months of dev, I can “afford” to make the needed improvements.  It makes sense as it would ultimately save me effort and frustration while costing my customer no extra time or money.  

Today I talked myself into thinking that refactoring/redesigning would be best for everyone and I promptly redesigned the database (all of it) and swapped out the data access layer (all of it) with the help of SSMS Tool Packs and SubSonic, respectively.  Of course, I had help. Lots of it. Hours and hours of other people’s time…  I’ve written about Getting Started with SubSonic and though I “admire” it, I hadn’t put it to good use until this morning.  SubSonic (after a quick review which consisted of watching this webcast) generated my DAL. SSMS Tool Packs was a lucky discovery as it auto-generated my CRUD routines.  The product offers much more than this and integrates with each version of SQL Server Management Studio, but I only needed stored proc creation today.  All told the entire change took less than 5 hours.  It would have taken far less time if I didn’t have a complete brain fart and chase my tail around an incorrectly established SQLEXPRESS connection string.  Pretty amazing if you ask me!

To sum things up, thanks to Rob Conery and crew for SubSonic and thanks to Mladen Prajdic for your exceptional contributions.  They really helped me get back on track with minimal investment today.  

I won’t say this tool has saved me days of time but has certainly saved me hours (especially on those hand-me-down projects which tend to require a good amount of clean up. )

You’ll find the tool works in VS2005/VS2008 as it leverages the existing Refactor menu. Simply install the latest version found on the CodePlex project site and then Select Text > Right Click > Refactor > Extract to Resource until you find yourself giggling to yourself.

I’m not a big utility guy, but this tool gets installed along with VS on work stations. Enjoy.

Here’s a bit more:

PrimoPDF is a free tool for high-quality PDF creation, comprising a user-friendly interface that enables printing to PDF from virtually any Windows application.

• Completely free, not just a trial version, and no user registration is required.
• Ability to optimize PDF output for screen (online viewing), print (standard laser printers), ebook, and prepress.
• Resultant PDF output conforms to the PDF 1.4 specification.
• Secure PDF files with 40- or 128-bit encryption.
• Add document information (e.g. title, author, subject, keywords) to converted PDF files.
• NEW: Full support for 64-bit machines.
• NEW: Double byte character support.
• NEW: Support of non-TrueType fonts.
• NEW: Enhanced support for Microsoft Windows 98, ME, XP and Vista as well as improved PDF viewing support on non-Windows platforms.
• NEW: Ability to merge/append PDF files upon conversion.

That’s it.  I like the product and wanted to share…

(By the way, they also have a Developer API which I haven’t played around with yet.)

Here’s what I can tell you:  I purchased their small business plan which gives me 2GB of space, unlimited repositories, unlimited Trac instances and unlimited developers for $6.95 per month.  It also includes nightly offsite backups, HTTP/HTTPS access to SVN repositories, 24/7 personal technical support (which I haven’t tested yet) and a 30 day money back guarantee.  Not bad, right?  Once one’s account is established (it does take 24 hours for initial account setup), everything is automated and and the control panels for both the repository and billing management are pretty easy to use. 

If you are looking for SVN hosting, they are worth a look.  I understand the same group, HostingPlayground, provides Ruby hosting as well.

Place a rubber duck on your monitor and describe your problems to it. There’s something magical about stating your problems aloud that makes the solution more clear.

This is an effective approach to problem solving.  I’ve actually had a duck work by my side for years now.  He’s a good, patient, loyal duck.  Of course, you don’t need a rubber duck.  Some people use email.   In the process of meticulously documenting their problem, which will ultimately be shipped to all the smartest people they know looking for help, the solution comes to them.  Some people call a colleague into their office, point at the screen and say, “I’d like to get a second pair of eyes on this.”  The request for review comes along with a detailed overview of the problem which, in turn, begets an answer to one’s own question.  As they say in the book, it’s magical.I stumbled upon an Interview with Hunt and Thomas which tells a bit more about rubber ducking.  It’s a quick read and it’s worth a look.

Reading your source code aloud, or explaining it to someone else, has concrete and documented value, whether in a formal setting of code inspections, peer reviews or just chatting with your cube neighbor, said Thomas. “Have you ever done this? You stare at a piece of code for an hour, debug and debug, and finally, in desperation, you pull your friend in from his cubicle. You start to explain the code and how it works, but then …” (smacking his forehead) “Oh, that’s it!”The audience laughed again, and most of them were nodding ruefully. In fact, Thomas said, you can even resort to “rubber-ducking.” “I don’t know why it works, but it works. You put the rubber duck on top of your monitor. Then, when you’re stuck on something, you start explaining what the code does aloud to the duck.” And before you’ve finished the explanation, the solution comes to you. You smack your forehead, and politely thank the duck, he said to general laughter.

Why do I bring this up?  I am currently on a 6-week leave of absence from work spending time with my wife and new born son.  Prior to leaving the office a few weeks back, I dropped my duck off on a colleague’s desk without any advanced warning that a duck-sitter was needed.  I know the sentiment was appreciated, but I’m not positive the significance was understood.  As I mentioned earlier, you don’t need a rubber duck.  All you need is to willingly share your problems aloud.  I was this person’s rubber duck.  They always came up with the answers on their own, but not before giving me the opportunity to listen.  

I hope my duck is getting an earful right now…

* Update: Previously, I incorrectly credited Hunt and Thomas with coming up with the phrase “Rubber Ducking.”  In fact, it was Greg Pugh who coined the term.  Thanks to Ed Davies and his considerate comment for addressing my oversight.