Hello (cruel) World

Book Review–Programming Microsoft ASP.NET 4

2011-12-29T23:03:00.001-06:00

Disclosure: I received a review copy of this title from O’Reilly

Over the Christmas break I finally had a chance to sit down and finish reading Programming Microsoft ASP.NET 4 by Dino Esposito. This has been on my bookshelf for quite some time (sorry O’Reilly blogger program…) for various reasons. Primarily, and despite protestations to the contrary, it feels as though webforms itself is teetering on the brink of irrelevance, if not oblivion and I naturally tend to gravitate towards titles related to newer and, perhaps, more relevant technologies. If you are like me, you probably want to know what is the point of reading this title, considering ASP.NET has been around for a decade and it looks to be loosing ground to it’s MVC sibling. Oddly enough, I’m more excited about the book after having read it than I was prior to reading it. There are two reasons why I suggest every (Microsoft-stack) web developer should read this title:

1. There is far more than ASP.NET programming here

There is no getting away from it - this is primarily a webforms based book. However, regardless of which flavor of ASP.NET (webforms vs MVC) you are using, this book contains a substantial amount of invaluable information which will directly benefit you. This isn’t a book for beginners – it assumes a pretty decent knowledge of .NET and web programming in general. It altogether bypasses the basics of creating your first ASP.NET solution and instead uses its real-estate to discuss the ASP.NET runtime, interaction with IIS, security, caching, state management and a plethora of other concerns that are required by anyone developing a web application using Microsoft’s technologies. There’s even a whole section devoted to client side programming, delving into AJAX, JSON and jQuery programming. There is definitely a significant amount of specialized information for the ASP.NET 4 crowd, but the book has plenty to offer everyone.

2. Dino Esposito reaaaally knows his stuff.

This is an extremely detailed, yet very accessible title. The author, Dino Esposito, is a heavyweight in the .NET world with a large number of MSDN magazine articles and books already under his belt. While he covers a myriad of advanced topics in depth, the book has the rare ability to keep the reader engaged. Esposito has the requisite background knowledge to explain not only how mechanisms work but how these mechanisms evolved during the lifetime of the .NET framework and ASP.NET. At 992 pages the book is a monster, but it never feels overwhelming and in fact the content is varied enough to keep the reader interested. He also does a great job of predicting concerns readers will have, including a section dedicated to addressing my primary concern – why use ASP.NET 4 to begin with…

Summary

If you’re a webforms developer, you should absolutely own this title. It is extremely detail oriented and well written and gets into low level nitty-gritty details. It’s not for the feint of heart, but if you love developing web applications on the ASP.NET stack, you’ll love this book. If you, like me, are more enthused about MVC development I suggest you head to a bookstore and flick through the book. There were definitely some sections that I skimmed over, but there there was no lack of relevant content. I hope and believe that you will find enough valuable information to make this a worthwhile read.

Another NHibernate Repository

2011-10-17T23:08:00.000-05:00

I’ve been having a lot of fun with NHibernate recently and, during my spare time, have a few pet projects that I like to work on to improve my skillset (especially because it looks like my company is going to give an ORM a test run in the not too distant future). Everyone has their opinion on whether or not a Repository with an ORM is a good thing or a bad thing, and I’m not going to rehash any such arguments, except to say the following:

I needed to stop implementing the same old LoadSomethingById, UpdateSomething, SaveSomething, etc. methods for every single data type in my service layer. I found myself re-inventing the wheel, albeit with different naming conventions, over and over again
While NHibernate does provide a layer of abstraction in and of itself, I was reluctant to couple a particular ORM to my solution (i.e. call _session.Load<SomeType>(id) directly from my controller/codebehind/whatever)

So, as a learning exercise (like the world needed another one…) I created my own version of a Repository with an NHibernate solution as the default implementation. No doubt it’s not perfect but it was pretty worthwhile from an educational standpoint and I feel it is far cleaner than my previous approach. Feel Free to supply any constructive criticism you see fit.

My implementation is similar to a number already out there, aiming for a minimal set of non-specialized operations in my repository contract. Included is a pretty ~~sweet~~ simple FindMany (and FindManyFuture counterpart) method which takes an expression and uses the expression as my queryover’s filter. Combined with this is the ability to specify a limit on the number of items returned and the number of items you want to skip over. Both are useful if paging is necessary and I always like to specify a limit on all of my queries to stop any chance of returning an overly large number of records which will then hydrate objects and slow my application to a crawl. Most of the other methods are pretty straightforward and correspond to common use cases when using any ORM.
My initial feeling is that this implementation as-is takes care of the bulk (~70%) ordinary queries. For extraordinary queries, and those used repeatedly that I would like to reuse, I use extension methods rather than a service layer (as in the example below). This provides specific functions to specific repositories (based on the generic type) and allows me to use a single

All in all, it looks a little something like this:

Here is the repository interface:

public interface IRepository<T, TId>
{
        T Get(TId id);
        IList<T> GetAll();
        T SaveOrUpdate(T entity);
        void Delete(T entity);
        ISession Session { get; }
        IList<T> FindMany(Expression<Func<T, bool>> expression = null, int skip = 0, int take = int.MaxValue);
        IEnumerable<T> FindManyFuture(Expression<Func<T, bool>> expression = null, int skip = 0, int take = int.MaxValue);
        T FindOne(Expression<Func<T, bool>> expression);
        T Load(TId id);
        T Save(T entity);
        T Update(T entity);
        void Delete(TId id);
}

Here is the default implementation:

  public class NHibernateRepository<T, TId> : IRepository<T, TId> where T : class
    {
        private readonly ISession _session;

        public NHibernateRepository(ISession session)
        {
            _session = session;
        }

        public virtual ISession Session
        {
            get { return _session; }
        }

        public IList<T> FindMany(Expression<Func<T, bool>> expression = null, int skip = 0, int take = int.MaxValue )
        {
            return expression != null ? Session.QueryOver<T>().Where(expression).Skip(skip).Take(take).List() : Session.QueryOver<T>().Skip(skip).Take(take).List();
        }

        public IEnumerable<T> FindManyFuture(Expression<Func<T, bool>> expression = null, int skip = 0, int take = int.MaxValue)
        {
            return expression != null ? Session.QueryOver<T>().Where(expression).Skip(skip).Take(take).Future<T>() : Session.QueryOver<T>().Skip(skip).Take(take).Future<T>();
        }

        public T FindOne(Expression<Func<T, bool>> expression)
        {
            return Session.QueryOver<T>().Where(expression).SingleOrDefault();
        }

        public virtual T Load(TId id)
        {
            return Session.Load<T>(id);
        }

        public virtual T Save(T entity)
        {
            Session.Save(entity);
            return entity;
        }

        public virtual T Update(T entity)
        {
            Session.Update(entity);
            return entity;
        }

        public virtual void Evict(T entity)
        {
            Session.Evict(entity);
        }

        public virtual void Delete(T entity)
        {
            Session.Delete(entity);
        }

        public virtual void Delete(TId id)
        {
            Session.Delete(Session.Load<T>(id));
        }


        public virtual T Get(TId id)
        {
            return Session.Get<T>(id);
        }

        public virtual IList<T> GetAll()
        {
            ICriteria criteria = Session.CreateCriteria(typeof (T));
            return criteria.List<T>();
        }

        public virtual T SaveOrUpdate(T entity)
        {
            Session.SaveOrUpdate(entity);
            return entity;
        }
   }

Example Extension Method

public static class ShopperExtensions
{
 public static Shopper GetShopperBySecurityToken(this IRepository<Shopper,int> repository, string securityToken)
 {
  return repository.Session.CreateCriteria(typeof (Shopper))
   .CreateAlias("ShopperSecurityProfile", "profile")
   .Add(Property.ForName("profile.SecurityToken").Eq(securityToken))
   .UniqueResult<Shopper>();
 }
}

Basic Usage


var shopperRepository = ObjectFactory.Container.GetInstance<IRepository<Shopper,int>>();

int shopperID = 123456;
var shopper = shopperRepository.Get(123456);

// OR USING SECURITY TOKEN AND EXTENSION METHOD

var shopper = shopperRepository.GetShopperBySecurityToken(securityToken);

In the above code you can see an example of using the Get method to get a particular shopper based on their ID and also a second example where an extension method is used to return a shopper based on their security token. (Note, in real-world code I would probably use constructor/property injection for my dependencies but go directly to the container in this example (ObjectFactory.Container…) for the sake of brevity.) The one change I definitely need to make is to remove the dependency on ISession from the repository interface. This (and now that I think of it maybe the Evict method) is the only place in the solution where the specific ORM solution leaks into my solution (so to speak). This property is only necessary so that any extension methods defined have a session they can use to hit the database.

Book Review - The Well Grounded Rubyist

2011-10-16T17:30:00.000-05:00

Disclosure: I recently received review copies of two books in Manning’s Ruby series. The first, and the subject of today’s review is The Well Grounded Rubyist by David A. Black.

These days it feels as though one couldn’t throw a rock in a major metropolitan area without hitting a ruby developer. Worse still, each appears more enthused than the last. This enthusiasm is either infectious or annoying, depending on the individual, but as a .NET developer by day I’m admittedly intrigued to see what all the fuss is about. While I enjoy the .NET stack and will be using it professionally for the foreseeable future, it’s time to balance my skill set somewhat and Ruby (on Rails) may be just the tonic - hence my request to review this title. Expect some future Ruby/Rails/VIM related posts!

I haven’t yet found a good reference explaining the different naming conventions employed by Manning in their series’ titles (let me know if one exists and I’ll post a link). The term “Well Grounded” had a similar effect to a realtor describing a property as “rustic”, and I I was originally skeptical, taking the title to imply something a little more basic and less thorough than this book actually is. I was completely mistaken - light and fluffy this title is not. Instead it is an enjoyable and detailed introduction to programming with Ruby, valuable to polyglot programmers and novices alike. I’ve read the title cover to cover (with many highlights along the way) and it will undoubtedly remain on my bookshelf long term as a useful reference to the Ruby language.

The author, David A Black, focuses solely on the core Ruby programming language, purposefully avoiding libraries and frameworks (no rails here) in favor of getting deep into the language itself - a wise move that allows a consistent focus and detail oriented approach. The book begins with an overview of the Ruby installation and command line tools which clarified much for me - a novice Ruby programmer. The remainder of the book iteratively builds knowledge of the Ruby language, explaining core mechanisms common to other languages (objects/classes/scope/etc.), moving onto Ruby’s myriad of in-built classes and finally delving into dynamic programming and introspection.

The book is well written, code samples are often simple but always effective and after reading the book I feel very comfortable getting started and writing some code of my own. What I enjoyed most about this title was David A Black’s insight into the Ruby programming language. Throughout the book he provides commentary on why things are they way they are. He doesn’t simply (as is often the case with similar titles) describe a construct and then move forward - he goes to great length to rationalize the usage of constructs and advises the reader when and why they should be used. Similarly he touches on the evolution of the language, citing mechanisms that have changed from one revision to the next - describing the problem and the fix - and also warning the reader when mechanisms he is describing are likely to change in the future. I find this type of insight extremely interesting and beneficial in my education on the language. I’ll be looking out for more titles by the author in the future.

If there are two things that I would have liked to have seen it is some coverage on debugging and testability. As I mentioned earlier, the book focuses on only the core language itself and perhaps these are not core language constructs, so to speak. However, for me, knowing how the language facilitates debugging and (automated) testing are key concerns and I was a little disappointed to reach the final chapter with little being said on either.

At the end of the day this is a great book, full of useful advice and worthy as an introduction to Ruby or a reference for seasoned developers. It covers Ruby 1.9.1 so is up to date and very relevant. I heartily recommend it!

data-placeholder in MVC3

2011-09-24T19:24:00.001-05:00

I ran into an interesting problem this evening with a very quick fix. I’m using the very neat chosen Javascript plugin (link) to add some aesthetic and functional sugar to a website’s existing dropdowns.

Anyhow, adding default text support (e.g. “Please choose an option”) to a multiple select dropdown is achievable using data-placeholder like this:

<select data-placeholder="Choose a country..." style="width:350px;" multiple class="chzn-select"">

Problem is, I am using ASP.NET MVC’s helper syntax to create my dropdownlists and “data-placeholder” is invalid syntax due to the dash character. The following does not work:

@Html.DropDownListFor(m => m.SelectedProductIDs, Model.AvaliableProducts.ToSelectList("ID","Name"), new { @class = "chzn-select", data-placeholder="Please select a product" })

Happily, Microsoft pulled a rabbit out of the hat and as of MVC3 underscores in html attribute properties are automatically converted to dashes, meaning that this:

@Html.DropDownListFor(m => m.SelectedProductIDs, Model.AvaliableProducts.ToSelectList("ID","Name"), new { @class = "chzn-select", data_placeholder="Please select a product" })

will generate something like this, with the place_holder converted to place-holder

<select class="chzn-select chzn-done" data-placeholder="Please select a product" id="SelectedProductIDs" name="SelectedProductIDs" style="display: none; ">

My First Experience with Windows 8

2011-09-13T22:53:00.001-05:00

I guess running in a VM was a bad idea then…

I wonder will the soothing BSOD thing catch on :-)

gitignore–Don’t ignore Nuget Binaries

2011-09-10T18:11:00.001-05:00

I am pretty new to the GIT world and am excited to be moving a personal project from Subversion to GIT. As with most .NET developers’ .gitignore files, I use the following line to filter out DLLs so that I am not versioning build DLLs

*.dll

I ran into an issue where I wanted to exclude all DLLs except for those stored in my Nuget packages directory. This wouldn’t in itself be an issue were it not for the fact that Nuget packages diverge wildly with respect to the number of nested sub-folders. Where one package might store it’s DLLs one folder down the directory hierarchy, another might store theirs down 10…

I searched for a recursive wildcard pattern that would work via mysysgit but hit a brick wall as none of the following worked:

!/packages/**/*.dll
!/packages/**/*

While I hoped for a cleaner solution it turned out that all I had to do was add another .gitignore to my packages directory containing only the following line:

!*.dll

Obviously this would work just as well for !*.exe or any other relevant binary file type…

TFS–Automated Project Creation

2011-05-26T17:45:00.000-05:00

I posted a while back about the…difficulties…migrating from VSS to TFS in terms of mass project creation and re-creation. Specifically, the process to create a team project in TFS is somewhat manual and it has been extremely frustrating re-initializing our TFS sandbox prior to every iteration of testing…until today…

Part 1

Today I stumbled across a useful nugget of information – there is a client-side Team Explorer command called File.BatchNewTeamProject located in the Microsoft.VisualStudio.TeamFoundation.TeamExplorer DLL located in C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies. This command is used by Team Explorer in Visual Studio to create a new team project. A little extra investigation led me to a Codeplex project (http://tfsprojprovisioner.codeplex.com/) by Brad Kaenel named Team Foundation Project Provisioner with the express purpose to

“1) Produce a .Net assembly that encapsulated all the fiddly code necessary to generate the required XML file and invoke BatchNewTeamProject;
2) To write a shop-specific provisioning tool that not only created Team Projects, but also did the necessary post-creation tasks that I needed.”

This code does everything I need and more (right now I don’t need to pull in AD groups etc.) solving part 1 of my problem.

Part 2

Building on this I decided to parse our existing conversion.xml files, used by VSSConverter to migrate VSS projects to TFS. The file looks a little like this trivial example:

<?xml version="1.0" encoding="utf-8"?>
<SourceControlConverter>
  <ConverterSpecificSetting>
    <Source name="VSS">
      <VSSDatabase name="C:\TFSMigration\vss_database"></VSSDatabase>
      <UserMap name="c:\UserMap.xml"></UserMap>
    </Source>
    <ProjectMap>
      <Project Source="$/BillingProject/BillingProject/Client" Destination="$/BillingProject/Client"></Project>
      <Project Source="$/BillingProject/BillingProject/Server" Destination="$/BillingProject/Server"></Project>
      <Project Source="$/FinancialProject/FinancialProject/Client" Destination="$/FinancialProject/Client"></Project>
      <Project Source="$/FinancialProject/FinancialProject/Server" Destination="$/FinancialProject/Server"></Project>
	  <Project Source="$/FinancialProject/FinancialProject/Common" Destination="$/FinancialProject/Common"></Project>
      <Project Source="$/StaffingProject/StaffingProject/Client" Destination="$/StaffingProject/Client"></Project>
      <Project Source="$/StaffingProject/StaffingProject/Server" Destination="$/StaffingProject/Server"></Project>
    </ProjectMap>
  </ConverterSpecificSetting>
  <Settings>
    <TeamFoundationServer name="myserver.mydomain.com" port="8080" protocol="http" collection="tfs/MyProjectCollection">
</TeamFoundationServer>
  </Settings>
</SourceControlConverter>

Obviously this file contains all of the requisite information to identify needed TFS (destination) projects and pulling this information out couldn’t be simpler:

static void Main()
{
	var uri = new Uri("http://myserver.mydomain.com.org:8080/tfs/MyProjectCollection");
	const string processTemplateName = "MSF for Agile Software Development v5.0";
	var projectProvisioner = new ProjectProvisioner();

	var loaded = XDocument.Load(@"C:\conversion.xml");
	var listOfProjectPaths = loaded.Descendants("Project").Select(x => ((string)x.Attribute("Destination")).Replace(@"$/", string.Empty));
	var listOfDistinctProjectNames = listOfProjectPaths.Select(x => x.Substring(0, x.IndexOf("/"))).Distinct();

	projectProvisioner.ProvisionProgress += MyProvisionerProvisionProgress;
	projectProvisioner.ProvisionException += MyProvisionerProvisionException;

	foreach (var project in listOfDistinctProjectNames)
	{
		projectProvisioner.Create(uri, project, processTemplateName, null, null);
	}
}

I created a simple console app, referencing the TFSProjectTools assembly from tfsprojprovisioner. Loading the conversion.xml file from my C:\ drive I was then able to loop through each project element and performed some simple string manipulation essentially turning this:

"$/StaffingProject/Server"

into this:

StaffingProject

and returning the distinct root projects. I looped through these projects and used the Create method in TFSProjectTools to create the required projects. That is all VSSConverter needs to be set up and I finally have a repeatable solution in place to create the requisite projects for our VSS migration.

Book Review - Programming Amazon EC2

2011-03-08T12:48:00.001-06:00

Disclosure: I received a review copy of Programming Amazon EC2 from O’Reilly.

I read somewhere that Programming Amazon EC2 is a title for people looking to adopt Amazon’s cloud platforms while avoiding a large amount of trial and error. I’ve been wanting to play around on this platform for a long time but have been a little intimidated by the myriad of terms and acronyms used to describe the available tools and configurations at my disposal. I fit firmly into the demographic that wants to get up and running with Amazon but doesn’t have the time to learn in this manner. The book is a pretty quick read and is packed full of useful information. Despite a couple of issues this is the de facto guide to Amazon’s web offerings and should (and will) act as a bible for anyone embarking on such a project. This book will undoubtedly save me countless hours in my future endeavors with these services and will pay for itself in no time. I highly recommend it.

While this book had a far narrower focus than most of the titles I’ve read recently it fit my needs perfectly and fulfilled its goal of getting me up and running with these services with little fuss. It is a pretty short title but very detailed, breaking down the key technologies and working through examples of improving the infrastructure of existing applications by adopting said technologies. The book starts with a brief timeline of when each technology was created by Amazon and, more interestingly, what gap they were created to fill. This was somewhat insightful and especially interesting when you consider the scale of Amazon’s online store and their adoption of said technologies. The proceeding chapters go into each technology in detail. The authors really know their stuff and there are some great tips from real life experience – some of which have the potential to save a lot of experimentation and frustration as one works their way through some existing idiosyncrasies. Furthermore the authors are cost-conscious and in a number of places provided guidance with regard to maintain resource utilization levels for optimum return on investment. The book provides a number of very useful scripts not only to create an environment but to monitor interesting metrics and planning for improvement once in the wild.

The book’s greatest strength is also its greatest weakness. As mentioned above, the content is based firmly on real world production applications. The issue with this is that it is written mostly from the standpoint of taking existing applications and moving them to the cloud. For greenfield projects there are some very important omissions which I found somewhat frustrating. Firstly, the authors do not discuss alternative development/testing environments. Specifically, when using a service where you pay money based on time, bandwidth etc. I wonder if there is any way to develop offline in a local sandbox or, for the two years it takes to bring the product to market, I am expected to pay regular Amazon rates associated with a production environment? Furthermore, am I expected to be constantly connected when developing a solution against SimpleDB, SQS, etc. It may seem like a small point but, when planning a new project, is extremely important. The answer might be straightforward (and I’m willing to bet most organizations develop against real AWS instances and are online all the time) but having read the title cover to cover I still don’t know the answer. Secondly, the authors omit information about licensing. Most of the discussion is Linux based, but I was really hoping for a breakdown of what is required if, say, I want to run Windows Server and SQL Server Enterprise. How does licensing work in these scenarios? If I get an AMI with these loaded then are my licensing costs included in the fees I am already paying, etc. Again, this is information that I would need before suggesting that my organization adopt AWS, but at this point in time I do not know.

Other than the above issues I really can’t say much bad about this book. It does exactly what it promises and provides a great introduction to the acronym laden world of Amazon’s web infrastructure. The material is extremely specific so this isn’t something I’d recommend to just anyone. But if you’re thinking about moving to the cloud then this title is a must. I could make a pretty good business case for Amazon to offer this title free to developers as it makes a very strong case for using their services.

Up and running with IIS 7.5 Express

2011-03-05T16:17:00.001-06:00

I’ve been excited to play around with IIS Express since Scott Guthrie’s announcement. I recently loaded up VS2010 SP1 and decided it was time to play around with IIS. The promise is wonderful – a lightweight but rich version of IIS – including SSL, URL Rewrite, media support, etc. - that doesn’t require elevated privileges to run and can even run on Windows XP.

After installing IIS Express through the Web Platform Installer things went awry. From the reading I had done on the subject it seemed like the express version would be a quick and easy alternative to the full blown IIS, but unfortunately configuration is (right now) a bit of a PITA requiring IIS Express config file editing, net shell configuration changes and quite a bit of trial and error.

I was expecting IIS Express to be a portable solution – but now see that it is going to be a bit of a pain to get configured how I like it when I move PCs or reimage my box. A certain amount of this is necessary due to the elevated privileges we need but are trying to circumvent (in my example below using well-known/reserved ports 80 and 443) but I wonder if updates to IIS Express application bindings could have been moved from the applicationhost.config file to individual websites’ web.config files allowing everything to be stored in version control systems, allowing multiple users to share said configurations and, in general, making life a little easier for everyone concerned…As things stand it is actually a lot easier – when one has admin permissions on their box – to get up and running quickly with the full blown version of IIS...

The Adventure

I immediately ran into problems using IIS Express with an ASP.NET MVC 3 application that relies on port 80 for http and 443 for https. Essentially, IIS express expects ports between 44300 (defaulting to this value) and 44399 to be used for SSL and trying to use another port, say 443, results URL binding failure…

A Great Intro to IIS Express

Too late in the process I came across the following video from MvcConf which goes over IIS Express in great detail and is a must for anyone using this tool:

http://channel9.msdn.com/Series/mvcConf/mvcConf-2-Vaidy-Gopalakrishnan-IIS-Express

Step #1 – Enable SSL in IIS Express

Add the following binding to the applicationhost.config file:

     <binding protocol="https" bindingInformation="*:44300:localhost" />

Step #2 – Change SSL PORT

IIS 7.5 Express uses port 44300 by default – not 443. RequiresSSL seems to default to port 443 causing secured pages to fail loading. The following resources led me to figuring out the issue:

http://forums.iis.net/t/1171280.aspx

and

http://learn.iis.net/page.aspx/1005/handling-url-binding-failures-in-iis-express/

The following needs to be executed from the command prompt running as Administrator…

' if you already have port 443 setup, you'll need to remove your existing entry
netsh http delete sslcert ipport=0.0.0.0:443
' Get SHA1 thumbprint - You will need to remove spaces
certmgr.exe /c /s /r localMachine MY
' Create a unique UUID using 
uuidgen.exe
netsh http add sslcert ipport=0.0.0.0:443 certhash=<your SHA1 thumbprint> appid={<your UUID>}
' add access control list entry to allow port 443 to be used by IIS Express when running as non-admin user
netsh http add urlacl url=https://localhost:443/ user=everyone
' restart http service
net stop http
net start http

Step #3 – Add binding for port 80

The next two steps are essentially a rinse and repeat of steps 1 and 2, but things are a little quicker this time round since we don’t have any certificate information to figure out. Add an additional http binding in your applicationhost.config file, this time binding port 80

    <binding protocol="http" bindingInformation="*:80:localhost" />

Step #4 – Add ACL entry for port 80

    netsh http add urlacl url=http://localhost:80/ user=everyone

    net stop http

    net start http

Fin

That’s it. If you followed these steps – and made sure all instances of IIS Express have been stopped and restarted – you should now be able to use ports 443 and 80 using IIS Express. Not a whole lot of fun but you should now be able to run a pretty feature rich web server without the need to run VS as an administrator…

Book Review – Conversion Optimization

2011-02-21T22:38:00.001-06:00

Disclosure: I received a review copy of Conversion Optimization from O’Reilly.

I didn’t really have any set expectations when reading this title. As a professional developer I continually strive to fill gaps in my knowledge and conversion optimization was (read: is no longer) something I didn’t know much if anything about. At less than 300 pages the book is a pretty quick read, but is packed full of useful information, lessons learned from real world conversion optimization and plenty of case studies. I read the book over the course of a weekend and highly recommend it for anyone involved in ecommerce or lead generation websites – from developers and designers all the way to marketing and business folk. There is a health balance of descriptive and prescriptive guidance and I feel like I learned a lot while thoroughly enjoying the read.

Overview

As the name suggests, Conversion Optimization by Khalid Saleh, Ayat Shukairy deals specifically with converting site visits into revenue – through sales/leads/etc. Essentially organizations spend fortunes on SEO and online advertising to drive people to their site, without giving enough thought to what to do when the visitors actually arrive.

The book is based on an 8 principle (trademarked) Conversion Framework which walks the reader from initial market analysis and persona setup through engaging customers. I found the early differentiation of macro and micro conversions to be extremely insightful, where getting the user to purchase something (taking an ecommerce example) is the macro level and every page along the way must provide a micro conversion to enable said macro conversion. Simple, yes, but only after it has been articulated…

Each step along the way is extremely detailed with a combination of qualitative and quantitative data backing up claims made. The authors appear to be experts in their fields and illustrate their points using real world examples that they worked on. The book is littered with interesting and useful case studies.

The book is both descriptive and prescriptive, explaining in detail what conversion optimization is, pinpointing why it is ignored by so many, defining a framework for optimization and illustrating how to implement this framework.

I read this book from cover to cover in about 3 days. It weighs in at less than 300 pages but the reading is somewhat fluid as the authors jump from business forecasting to the psychology of users and onwards to a multitude of topics with the greatest of ease. I was pretty riveted throughout and barely put the book down once I had started reading.

This is an excellent title which (if anyone from O’Reilly is listening) would greatly benefit from being turned into a Master Class video series! It isn’t a technical title, and should be accessible and useful to anyone from business stakeholders, to marketing fold and all the way down to us developers and designers. This was a great read that I strongly suggest for anyone interested in deriving revenue from their website – specifically those spending a fortune on ADs and SEO wondering why customers are not buying their product.

Review - Scott & Neil's Designing Web Interfaces Master Class

2011-02-17T12:57:00.001-06:00

Summary

As a developer I tend to (subconsciously) consider web interface design as a soft art that takes a back seat to the science of computer programming. I’ve long needed to brush up on my design skills and was excited to review O’Reilly’s series - Scott & Neil's Designing Web Interfaces Master Class. I was hopeful of an in-depth overview of web interface design with plenty of battle-hardened nuggets of wisdom. The presenters were sufficiently credentialed to offer such nuggets of wisdom and to me, the best part of this course was Bill Scott’s insight into designs from his time at Yahoo! and especially his current company Netflix extremely interesting. While I enjoyed this course and gained some knowledge in the process, I’m not sure that I – a UX rookie – learned enough for this series to live up to its master class title. I certainly don’t feel like I gained mastery of the subject matter in the process. Pedantic, I know, but those were my expectations based on the title and they weren’t really met by the content. The series isn’t bad by any stretch of the imagination – it just didn’t fully live up to my expectations.

Overview

As with the previous O’Reilly video series I reviewed, the series production was of extremely high quality with superb audio and video providing an immersive experience. The presenters were both extremely competent, knowledgeable and well-spoken and had plenty of relevant experience.

A minor annoyance with the content is that, when demonstrating key layout points, the presenters used screenshots and/or videos. While I’m sure that logging into the many websites utilized as examples in the series would have constituted a logistical (and personal privacy) nightmare, the use of static screenshots and video recordings didn’t really work. There were a number of awkward moments throughout the series where the presenter wished to illustrate a point and resorted to rewinding video or, worse still, pointing at a static screenshot and asking the viewer to use their imagination.

The course got off to a pretty slow start. The longest video (weighing in at almost 1.5 hours) introduces a myriad of possible screen layouts with suggestions as to which layout should be used when. Unfortunately the video is long winded and pretty subjective – what I loved about the Croll & Power’s Communylitics Master Class video series was that everything was backed up with statistics and/or studies. When reviewing different layout options I would have loved to see some similar statistics applied – specifically detailing why users act the way they act with comparisons of layouts based on quantitative data and detailing where users spend their time on websites, etc. etc.

Instead, the screen layout and user control videos felt more like best of the web affairs with the presenter spending a substantial amount of time showing off really nice websites, grouped by layout/control types. While there was nothing wrong with these videos (I would love O’Reilly to make and distribute a poster with all of the included layout types and screenshots) the same impact could have been achieved in a lot less time. Also, knowing that combined these accounted for almost 50% of the series, I was a little disheartened having finished watching the titles and feeling that I really hadn’t learned all that much.

As the series progressed a bunch of patterns and anti-patterns were discussed. The series really came into its own with Bill providing many insights into designs at Yahoo! and Netflix and I found it refreshing not only to hear about (and see) real life experiences of good and bad design decisions but to gain insight into the world of prominent and relevant web giants – this is something you don’t often get a chance to see!

All in all I found the series to be useful without fully living up to expectations – had this been advertised as an introduction or even a mid-level course then I think the title was acceptable, but as a master class the information was not prescriptive enough. If I, as a developer with little design experience, didn’t gain much knowledge from the title, I can’t imagine that a designer would gain anything at all. I would recommend this series as I thought it was both enjoyable and a worthwhile watch – but I would adjust my expectations a little before watching…

Book Review - Event Processing in Action

2011-02-11T12:54:00.001-06:00

Disclosure: I received a review copy of Event Processing in Action from Manning.

I started this reviewing kick a little while back with Manning’s Continuous Integration title and, enjoying the experience, decided to continue with additional reviews for the foreseeable future. To get the most out of the experience I’ve decided that wherever possible I should review titles that do not directly relate to the things I work on as part of my day job in order to broaden my horizons a little. The most recent title in my repertoire is Manning’s Event Processing in Action by Opher Etzion and Peter Niblett.

Background

Let me start by saying that, other than a rudimentary understanding of the base concepts, I began reading the title with a sum-total of zero knowledge of formalized event processing. I currently work in the healthcare industry and can see many practical applications of such a formal approach – from medical equipment monitoring patient health to reception of third party lab results, medication orders etc. it seems that a lot of what we do is essentially event processing – but we don’t always treat it as such.

My Expectations

Define the basics
Explain why event processing would be beneficial to me
Provide advice based on real world experience

The Book

In short this book is a substantial body of effort, extremely well written and detail-oriented. I wouldn’t call it enjoyable reading per se - it is not a particularly sexy topic to begin with – but definitely a worthwhile read.

Event Processing in Action, as expected, starts out with an introduction to the world of event processing – providing detailed definitions of key terms as well as examples of computerized event processing. Event processing applications are then categorized and, most importantly, the authors explain when and why event processing should be used. This is pretty much exactly what I was looking for in an introduction. Moreover, everything was defined with extreme clarity and I was left with very few, if any, questions unanswered.

The bulk of the book deals with the standard building blocks that constitute event processing systems – an attempt to abstract away from a particular language or system and explain the constituent parts of such a system in a generic manner. If I had one reservation about the book it is that it is (mostly) language agnostic – I like to get my hands dirty and would loved to have seen at least a few chapters dealing with the setup and application of a real world system using a real world language – after reading the book I feel pretty well briefed in theory but not so much in real world application. As with the introductory material, the building block chapters go into great detail, discussing event types, consumers, producers, filters, etc. etc.

My favorite section in the book dealt with the pragmatics behind the implementation of an event processing system including engineering and implementation considerations – specifically looking at non functional properties such as security, performance and availability. While this section was more descriptive than prescriptive it was refreshing to read and provided some interesting areas of discussion if/when my organization embarks upon an event processing solution.

Summary

All-in-all this was an interesting and detailed book definitely worth reading. It hit all 3 of my expectations and I feel informed enough to implement and event processing system in my organization. Moreover, the book changed my mentality in terms of how such systems are architected – I think in most organizations there are numerous candidates for event processing systems that were structured in a less natural and less efficient manner. By reading this title, perhaps we can avoid some of the same mistakes the future – or at least have enough information at hand to make appropriate decisions.

The Rise and Fall of my Notion Ink Adam

2011-02-04T14:07:00.001-06:00

Today I’ll take a break from the world of programming to discuss my purchase, use, and immediate sale of the Notion Ink Adam – the latest pretender to the iPad throne. I’ve been waiting for this device since CES 2010 and, after a number of hiccups, it is finally here. If you’re looking for something with a few more curly braces, please come back tomorrow. Otherwise read on for my early opinions.

Introduction

Before I get started with the device I’m going to give my two cents on the company and the preorder process. If you don’t want to read this (or if you feel like starting a flame war which I really don’t want to get into) feel free to skip the next two sections. My goal isn’t to defame Notion Ink in any way. You wouldn’t marry someone without meeting the in-laws. The manufacturer is to the in-laws as the gadget is to the bride…if you stand under me…

The Company

Let me start by saying that I am impressed by what Notion Ink has achieved. For a small startup to achieve something of this magnitude is rare and impressive in equal doses, and I have to applaud anyone with the audacity to attempt to compete at this level. What I do not applaud is the arrogance the company has shown in ignoring its user-base. Time and again they have failed to release information, failed to answer questions, failed to provide updates regarding order timelines and shipping estimates and really, failed to be objective about their product. Only good news ever seems to make the cut, questions are answered arbitrarily (i.e. only questions with a happy answer are acknowledged) and the language used seems more indicative of a group of school kids at play than a large company. By all accounts the organization does not consider itself bound by the same rules as large multi-nationals, often spouting the argument that the Notion Ink Adam is not just a product – it is a dream coming to fruition - as if it transcends the needs of a regular device because of what it iconizes. Trying to get a straight answer to a legitimate question is a lesson in futility and, oddly, NI has built a small army of die-hard followers, seemingly without the benefit of critical reasoning (but with a healthy dose of naivety), who are willing to battle any genuine concern or criticism, towing the same bizarre party political line. I get particularly nervous when people refuse to hold their representatives accountable as is the case here. Squeaky bum time, so to speak…

The Ordering Process

Oh, the ordering process... I can say, without hesitation, that ordering the ADAM was the singular worst retail experience I have ever had. Period. I’m always wary of pre-sales treatment that I receive, because I know that once a company has my money, they will never have the same motivation to treat me well again. In short, pre-sale time is as good as it gets. If this is the best treatment I can hope for then I fear what is to come (for those who stay onboard). The ordering process was plagued by delays, expectations that were set but not met, a lack of any tangible information regarding the device (renders do not suffice), servers crashing, unstated charges ($50 shipping. Not unreasonable, but should have been made known), lack of any proactive communication and credit card issues (for many, not me). I, like many, stayed up all night waiting for the unveiling of the preorder page, then waiting for the email with my preorder link, then waiting for the preorder time to roll around, then waiting for hours after the preorder time rolled around while the preorder page still suggested I come back at the original (long since passed) preorder time, then waiting patiently, refreshing in the hope that Notion Ink’s server would come online (or at least allow me get to the page necessary) so that I could order a tablet which, in hindsight, I did not know enough about. All the frustration, and all of the negativity I felt towards NI could have been belayed with a simple email or blog post by the company, explaining the situation to their users. Unfortunately, Notion Ink does not work that way..

Why I bought the Device

So, rant over (for now). You’re probably wondering why I bought the damn thing. Well, I was having second thoughts about the Adam even before clicking the order button. Notion Ink had missed all of their pre-order deadlines, their site was going up and down like a yoyo and I still had seen nothing of the device outside of an early CES2010 demo and more recent screen renderings. The fact is, I had waited a year for this device. A year of reading blog posts and blog comments and most importantly a year of anticipating. I had seen demos of this device before the first iPad was released and had emotionally bought into the product way back then. Over a year later I could have chosen to wait for the next big thing – but chances were that was a few months away – and frankly I had come too far to turn back. So, accepting the risk, I handed over my credit card information. While I feared the worst, I accepted responsibility for the device’s flaws, because I am an early adopter and the cutting edge tends to be pretty sharp.

The Build Up

To their credit, when the device became available, NI shipped their first round via air and the turnaround time from China to the US was 3-4 business days (with a weekend lodged in the middle). Shortly afterwards, issues began to surface on forums regarding bricked devices due to an over-the-air update, buggy software due to the lack of the over-the-air-update (after it was pulled), screen issues, bleeding colors, etc. etc. This was the last thing I wanted to hear but, to be fair, I have no idea how many Adams were shipped in the first round and therefore no idea of the percentage of people actually had issues. To clarify, rumors of bricked devices were misleading – a bricked device is one beyond repair – Notion Ink provided a new ROM to affected users in very little time and, to my knowledge, they addressed any issues caused by the OTA update. Not only that, but their turnaround time was extremely quick – fixing the issue the same day it was encountered…I was definitely apprehensive based on early feedback from other customers, but did my best to remain unbiased in the interim.

The Screen – PixelQI

I think the PixelQI screen (couple with the tegra processor) are what drew me to this device. Unfortunately, I was greatly disappointed by how it looked. I had realistic expectations – this was never going to look like a kindle – but the PixelQI mode definitely didn’t live up to expectations. For starters, it was impossible to read anything indoors – one needs a LOT of light for the text to be legible and, even when it is, the screen reminded me of a giant CASIO calculator. The contrast between text and background was not enough to make the text prominent and I ended up using it a handful of times and then giving up on it. My hope was that this would be useful indoors as a low-power alternative to full lcd mode. But, with the lights on in my apartments, I strained attempting to make out the text on the screen. Unfortunately, the tradeoff of PixelQI is that in LCD mode the screen is not as vibrant as a regular screen appearing a little washed out. In the end there was no benefit to outweigh this massive negative and I ended up disappointed…I’d like to see some other PixelQI examples because I’m not sure if this issue was caused by Notion Ink’s implementation or if my expectations were too high. Regardless, it is not the eBook reading experience I had longed for…

The Hardware – General

The Notion Ink seemed sturdy enough to me, but my wife (comparing it to an iPad) thought it looked and felt cheap – perhaps the difference being Notion Ink’s plastic construction. It felt similar in weight to the iPad and felt pretty good to hold. What I detested, and it is partially my fault for not reading the specs more closely and partially Notion Ink’s for showing misleading screen renders, is how long and skinny the screen was compare to that on the iPad. Holding the device vertically to read a book, the screen was very tall but very skinny in width and the reading experience felt quite bizarre and not something I would get used to. The sound, as other reviews have mentioned, was pretty good and pretty loud and didn’t have any complaints in that arena. I had intermittent issues watching videos on the device (and read similar complaints from other owners) where sometimes everything would be fine and other times (watching the exact same part of the exact same video) the sound would be delayed. This was particularly frustrating as it is something I’ve grown accustomed to just working and when things go wrong I get a little cranky. The swivel camera is a neat idea, but frankly was a little less sturdy than I would have expected. Frankly speaking I’d be just as happy with a front and rear facing camera – but I do not see any use cases where I will record lectures, etc. Finally, I hooked the device up to a 37” LCD TV in order to test HDMI out – and it failed miserably. Essentially, the video slowed down (like it was being played in slow motion) as if too much processing power was required to play the file. This was reproducible and, frankly, made the feature useless to me.

The Software

Ebook Reader

I was gutted to find out that the ADAM (currently) ships without ANY eBook reader. Clicking an ePub in sniffer indicates that there is no app associated with that file type and there definitely aren’t any applications installed that would prove otherwise. This is a BIG deal to me – reading eBooks will probably be my primary use of the device (which is why I bought the PixelQI version) but is not supported out of the box. To those who suggest using a third party android app: aldiko does not scale well to this form factor and the text looks horrible, making it next to impossible to read anything on there. Kobo looks a little better, but the android version is feature poor (unlike the beautiful iPad version). I haven’t yet found anything to rival iBooks which, to be honest, I never considered an amazing piece of software (it does its job well, but there are few bells and whistles). NI have mentioned content partnerships, and an eBook leaf definitely appears in multiple of their newer videos, but right now there is nothing….

Eden

Notion Ink’s custom Eden interface is one of the nicest aspects of the device – out of the box the interface was ridiculously buggy, to such an extent that I could no longer wait for Notion Ink to fix their over-the-air updates and instead opted to flash the firmware to get the latest and greatest version. Immediately the user interface became far more responsive with a lot fewer crashes and the interface felt a lot more like the widget goodness Android users have grown to love rather than the typical iPad application launcher screen. There were few applications available that had a leaf mode, but the ones that did (sniffer, mail, browser) were pretty nice and made information easily accessible. Oddly, I never cared about the custom UI, but this is one of the device’s nicest features…I’m not sure if that is a good thing or a bad thing.

Sniffer

A big annoyance I had with the iPad was the rigmarole necessary to transfer a few files to the device or move said files between applications – I understand the need for sandboxes and safeguards but I always felt way too controlled when using the iPad and that frustrated me…a lot. There are a bunch of file browsers available for Android and Notion Ink’s version, Sniffer, is extremely nice. The launcher itself is (I think) quite pretty and it was a lovely experience to be able to navigate to a folder and open an MP3 or open an ePub without having to do it through a specific application. I also loved Eden’s sniffer leaf where it was possible to browse to and open files straight from my main screen – to move, delete, etc. I just had to launch the main app from the leaf. While I don’t see it happening I’d love to see Notion Ink open sourcing or selling Sniffer to make it available (in an above board manner) on other Android tablets. They definitely have some talented developers and designers on board and I’d love to see what else they are capable of, without necessarily needing an Adam.

Browser

The default browser shows promise but, even with the latest and greatest firmware, was quite buggy. For instance, typing an address into the address bar and hitting enter didn’t do anything at all, and I was constantly forced to close the application and/or do a google search rather than being able to move between sites. This was frustrating enough that I side-loaded Dolphin HD after about 4 uses and never went back. Sadly the browser looked really nice and the tab interface was pretty cool, but it just wasn’t ready for general use…

Mail’d

I love K9, an open source Android mail client. Mail’d is built on top of K9 and supports most if not all (I only connected a gmail account during my time with the device) of the features of K9 while adding some style and fitting the Adam form factor. It is also really good looking – sharing the same style as sniffer – and, complete with its trimmed down leaf mode version, was an enjoyable and functional mail client. Notion Ink

What Is Missing

The android market for one thing. Sure, you can side-load many apps, but the inability to actually buy and download apps from Google felt like a pretty big void. Genesis, Notion Ink’s app store, is set to go live at an undetermined date but I wonder if enough developers will be willing to program for a specific device to enable it to gain traction.

The End

In the end I decided to sell my Notion Ink Adam. After spending so much time researching, discussing and anticipating it was sad to do so – but I knew if I waited until general release I would be unable to find a buyer. There were simply too many issues - physical, software and company related – to ignore and I knew I’d spend the lifetime of the product apologizing for the device. I’m saddened to think what could of happened had Notion Ink not had so many investor problems and this device was launched before the iPad last year. In this case time-to-market is everything and I fear the worst for Notion Ink. They seemingly do not have the necessary infrastructure to treat their customers the way (we high maintenance and technically competent) customers deserve and demand to be treated and I fear their loyal fan base will quickly dwindle if their communication strategy does not soon change for the better. The Notion Ink Adam feels like an unfinished product and, while I hope to see another version competing with the iPad (and other tablets in the future), I fear for the future of the Adam and Notion Ink as a whole. I recently sold my Adam and haven’t really looked back – since I received the Adam there have been no real updates on the Notion Ink site, and had I not upgraded the firmware manually, I’d still be using their bug-riddled V1 software…I wish all those who did (or will) buy an Adam all the best and hope that Notion Ink’s promise of innovation is realized in the future. I, for one, am going to pick up a Xoom when it is released later this month!

Review - Croll & Power's Communilytics Master Class

2011-01-07T14:43:00.001-06:00

Quick Summary

I was eager to watch these videos but didn’t know what to expect. Happily I was met with excellent content, explained by an entertaining an knowledgeable instructor in a very well-produced package.

Introduction

Like many developers, I am proficient in conceptualizing, designing, planning and implementing solutions, but after product delivery – when it comes to marketing and optimizing products for their target audience – my skillset thins out a little. While there is a wealth of information out there but finding cohesive and up-to-date information is near impossible. I was therefore excited to receive O’Reilly’s title Croll & Power’s Communilytics Master Class for review.

Production Quality

This is the first O’Reilly video series that I had watched and I approached the title with slight trepidation. The Master Class is the recording of an in-person class that has been formatted and made for sale. I’ve seen similar offerings from other vendors in the past where production value was an afterthought – oftentimes with such offerings it is impossible to see the slides/whiteboard the presenter is working from, audience questions are muted and video quality poor at best. Fortunately O’Reilly has done a great job on this title – and I am hopeful that their other titles are similar. Rather than pointing the camera at a screen/whiteboard, content slides have been merged into the feed during production and are displayed in full screen during video playback. Audio and video are crisp and the camera work is extremely professional (moreso than in any other classroom title I have seen). In essence production value is like a referee – you really only notice it when its bad…

The Speaker

While the content was created by Alistair Croll and Sean Power, Mr. Croll is the speaker for the entire master class. He does a fantastic job of engaging the viewer and blends pre-prepared and conversational information masterfully. The subject could have been extremely dry with plenty of numbers and statistics to quote, but is somehow delivered in an entertaining fashion throughout. Time flew by when watching these videos – a testament to both the content and Mr. Croll’s presentation skills. This is the first time I’ve seen anything delivered by Alistair Croll but I’ll make sure to look out for more in the future.

The Content

This series contains approximately 3.5 hours of video, full of valuable information regarding web analytics and community building. For the most part the information tends more towards descriptive than prescriptive as the course leads the viewer through many of the pitfalls and opportunities analytics helps to address, including a number of case studies. Data is quantified and claims are backed up with real world studies and experience. The content is extremely accessible and would be equally beneficial and comprehensible to a marketing manager or developer.

The Price

Compared to a $200 annual Tekpub subscription (and similar counterparts) the course seems a little expensive at $80. On the other hand, compared to attending such a class in person the price seems very reasonable. Inevitably spending decisions come down to cost benefit analysis and I can safely say there is a ton of information here to justify the purchase. It is difficult to put a price on knowledge. However, I tend to value an hour of my personal time (quite conservatively, may I add) at $20. I can say without a shadow of a doubt that the knowledge, tips and shortcuts in this series will save me more than 4 hours (and $80) in the future.

Conclusion

I was eager to watch these videos but didn’t know what to expect. Happily I was met with excellent content, explained by an entertaining an knowledgeable instructor in a very well-produced package. If anything this series needs a sequel – and I would be first in line to purchase it.

2010 - The Year of the eBook–A Comparison of Technical eBook Publishers

2010-12-12T20:17:00.001-06:00

I officially declare 2010 the year of the eBook. In July I purchased an iPad – my first eBook reader – and my reading habits have changed somewhat dramatically. I am buying more than ever, reading more than ever and my thirst for knowledge has skyrocketed – a result, I believe, of accessibility to my whole library anytime, anywhere.

My physical to digital (2009) transition from CD to MP3 highlighted a single important fact – I am a hoarder. Sure, I love to read and I love to listen to music. But probably not as much as I like to collect things, hoard things and, as I believe is often the case with those who like to hoard (embarrassing as it is) to show off those collections…there’s nothing quite like a bookshelf full of intelligent looking books… :-)

In the 6 short months since I bought the device I’ve built up a substantial technical library (and a non-too-shabby non-technical library) of digital books. I’ve purchased from pretty much every technical eBook vendor in the .NET space with varying degrees of success and in this post hope to summarize my experiences.

Note: While PDF is obviously a portable format, when I discuss mobile formats I’m focusing on ePub/mobi and other formats that better suit eReaders and tablets – including the ability to reflow text, resize fonts and provide the reader with a better overall reading experience

Criteria

These are the things that affect my eBook shopping habits and therefore on which vendors are rated.

Cost/Deals
- Bang-for-my buck is an upmost consideration. If I really want/need a particular book then I will buy it regardless. However, for anything on my medium-to-long-term wish list, I am easily won over by a good deal or promotion. A number of technical publishers wisely leverage email promotions/daily deals/etc.
Upgrade Path
- If I buy a print book I expect an option to attain the eBook, for free or at cost. If at cost, I expect it to be reasonable – if I’ve already bought one version of the book it shouldn’t cost the same amount to buy a digital format of the same book.
Available Formats
- I believe that when the dust settles the ePub format will emerge the victor. The format seems pretty open compared to proprietary format, but allows for DRM and other mechanisms desired by publishers. Regardless of who reigns supreme, I want the option to read my book on an iPad or kindle or whatever comes next. To me the formats supported reflects the publisher’s progressive mentality (in this industry it is a must) and agility when change occurs.
Access to Downloads
- When Google’s eBook store was announced, I was confused by the advertised personal cloud storage. At first I took this to mean one could access their downloads at any point in the future – a feature prevalent now but one that a number of vendors have only introduced in the last few months. Google, however, was talking about something more – the ability to read your books from any device (PC, Android, iPhone, etc.), picking up from where you left off. While this is an extremely cool feature – similar to the Kindle's offering – it is something that doesn’t interest me outside of a “how did they program that?” sort of way. I like the dedicated iBooks app on the iPad and do not expect to read much on my desktop pc or my android phone. As such, the feature really does nothing for me. What does matter is the more rudimentary ability to get at my files now and in the future. At this point pretty much all of the vendors on the list have a portal for you to grab your books from, making life easy. Anything beyond that doesn’t excite me much.

Publishers

Below is a breakdown of vendors and my reflections on my experiences as a whole. I am not rating the quality of content – there are too many variables (authors, content type, technical level, etc.) for me to feel comfortable to rate the publishers themselves. However, after spending months purchasing and consuming digital books I am confident that my feedback aptly summarizes each vendor’s eBook capabilities.

Manning (4 out of 5)

I’ve always been a fan of Manning’s contend and I’ve bought a bunch of Manning print and eBooks over the past year.

The Good

Manning offers a free digital copy of their titles with the purchase of a hard copy. When I originally bought my eBook reader I was able to obtain copies of a couple of recent purchases – at no extra cost. Since then, I’ve bought a number of hard copies with the knowledge that I would also receive the soft copy – had the soft copy incurred an additional cost I might not have done so. I feel that Manning is quite progressive in this regard and the ability to attain the digital copy free of charge has built a lot of goodwill in my mind.
File types – Manning offers the three file types that I care most about.
- PDF
- epub
- mobi
Up to recently you had 5 days to download a title after which time it was no longer available. Manning has added a portal for customers to download all of their content at any point in time.
Manning has daily deals (and Christmas raffles) offering heavily discounted print and/or eBook titles. Frequently eBooks are offered for $15 - I cannot tell you how many of these titles I have purchased but I probably don’t have enough hands to count them all :-)
DRM Free

The Bad

A number of older titles do not have ePub/mobi versions and are limited to PDF. There are a few titles (WPF with Visual Studio 2008 for instance) that do not have updated equivalents and for which no ePub/mobi is available). It would be great if books from the last X number of years were also upgraded (though I understand why this might not be possible)
Manning is a little slow releasing ePubs/Mobis for new titles. That said, they provide clear information as to which titles are next up for conversion under their mobile format section.

O’ Reilly (4 out of 5)

O’ Reilly has the benefit of selling both O’Reilly and Microsoft Press titles. I’m a fan of both and have bought a number of books in the last year.

The Good

O’Reilly offers more eBook titles (specifically ePub/Mobi) than anyone else I’ve seen. Their catalog, combined with MS Press titles also sold through the site, is simply enormous.
O’Reilly currently offers a cheap upgrade option - limited time $5 upgrades – for those who purchase print versions of their titles. Manning has daily deals offering heavily discounted eBook titles. Books tend to be in the $10-$20 range.
DRM Free
File types – O’ Reilly is the most progressive in this area, offering more file types than anyone else I’ve seen

The Bad

While I consider $5 a very reasonable price for eBook upgrades, given that Manning’s are free O’Reilly loses a point here. Also, the $5 upgrade is coupon based and feels like it may be transient.
O’Reilly’s daily deal used to be $9.99 consistently. In the last month or two this appears to have change to $14.99. While still great value for money, the initial price point was more satisfactory.

Packtpub (2 out of 5)

Packtpub has been the biggest disappointment for me this year. They have quite a large range of books on a wide variety of topics and I don’t doubt the quality of their work. However, I have made multiple purchases at different times this year where the product page specified that an epub version of the title is available, only to find after purchase that this is not the case. At best there is a lack of communication and transparency. At worst dishonest bait-and-switch tactics are being employed. Customer service has been apologetic, but as of writing this post the same titles remain with the same promises on their product pages – but still no ePubs in site.

The Good

Large selection of titles – including technologies not available elsewhere
Weekend deals and some extremely cheap seasonal package deals
DRM Free

The Bad

Lack of transparency – you may not get what you thought you were getting.
Limited File types – Packtpub is limited to the following 2 file types:

PDF
epub

Google Books (New) – (Not enough Information for Rating)

Google’s online bookstore launched a couple of weeks before this post was published but, as with all things Google, is exciting (or scary – depending where you are coming from) due to its sheer scale. There are a ton of books available. To date I have only purchased one, but it certainly won’t be my last.

The Good

Massive range of titles

The Bad

To date prices have been pretty standard – however there are no signs of any regular or seasonal deals that would force me into impulse buying. Hopefully this will be rectified in the future.
Google is currently pushing its own reader app
Limited File types – Google is limited to the following 2 file types:

PDF
epub

ePubs are DRM’d

The Others

There are a large number of vendors out there that I simply have not shopped with and thus couldn’t include in this write-up. I’m really hoping that in the next 12 months both Wrox and Apress get their acts together and offer a) a bigger lineup of ebooks and b) upgrade paths to those who bought print copies. Right now I have a bunch of print books from both publishers that I plan to read, but are taking a second seat to their electronic counterparts. I’ve reached the point where I will do everything in my power to avoid buying a book that doesn’t have a mobile version. Hopefully my collection will be 100% electronic this time next year!

Protecting myself from myself

2010-11-20T12:15:00.001-06:00

Note: This is a COMPLETELY non technical post. Feel free to skip…

Back home (in Ireland…I now live in the US) the fall series of international rugby is in full swing. In order to watch every game I need to run through a few hoops and a combination of energy levels and other commitments means that I rarely get to see the games live on Saturday mornings/afternoons.

What is worst of all is that I have a subconscious tendency to navigate to the RTE (Raidió Teilifís Éireann – Irelands public service broadcaster) website many times a day, inevitably discovering game scores on the homepage and somewhat defusing the excitement of the games before I’ve had a chance to watch them.

I decided to take a stand and protect me from myself – I found a nifty little extension for Chrome named StayFocused which allows the user to define a daily allowance of time to be spent on a site per day. Setting this to 1 minute (while holding a notebook in front of my monitor to block the live score of the game :o) ) allowed me to block access to the RTE site on my computer for the day. Navigating to the RTE website I’m immediately redirected to the above page. Awesome!

Visual Studio 2008 – Garbled Text in XAML View

2010-11-15T11:56:00.001-06:00

Since switching to Windows 7 on my work laptop I've had pretty constant issues with the XAML designer in Visual Studio 2008. Essentially, when I scroll through the XAML code the text becomes garbled and near impossible to read. Switching back and forth between views works, but is a dirty, frustrating and somewhat time-consuming solution. It is also one of those things that works fine on everyone else's computer (to be honest I'm still not sure why) and is difficult to find appropriate keywords for when searching online.

This morning I came across an issue logged on Microsoft's connect page (http://connect.microsoft.com/VisualStudio/feedback/details/465834/visual-studio-2008-xaml-editor-doesnt-paint-properly) with similar symptoms to my own. In the comments section Mark Wilson-Thomas (of the WPF and Silverlight team) suggested doubling the number of available GDI handles - which is defaulted to 10,000 on Windows 7.

So, I updated the following registry key DWORD value from 2710 hex (10,000 decimal) to 4e20 (20,000 decimal)

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows\GDIProcessHandleQuota

I then restarted VS2008 and, voila, no more garbled text. Happy days!

What a Difference a Clear Error Message Makes

2010-10-15T16:45:00.001-05:00

Let me be the first to say (and everyone should echo in harmony) that this issue was 100% my fault. Today I spent at least an hour of my life trying to track down an issue caused, simply, by the fact that I was trying to mock a sealed class without realizing it…

The point of this post is not to illustrate what went wrong. The point of this post is to show the error messages displayed by two popular mocking frameworks and highlight the benefit of clear messages. Recently I’ve been using Telerik’s JustMock framework but in the past MOQ has been my framework of choice. I’ve always found MOQ’s messages useful – it seems like the developers put a lot of thought into what the user sees – and after struggling to debug the issue for a while I figured I’d switch frameworks (for this individual test) to see if it would provide any more insight.

Take a look at the difference between error messages. Which one would you prefer?

JustMock

System.InvalidProgramException : Common Language Runtime detected an invalid program

MOQ

System.ArgumentException : Type to mock must be an interface or an abstract or non-sealed class.

Note: I’m not trying to bash JustMock in any way. To date I have been pretty happy with said framework and this has been somewhat of an isolated issue…

Book Review–Continuous Integration in .NET

2010-09-29T22:49:00.001-05:00

Disclosure: I received a review copy of Continuous Integration in .NET from Manning.

I don’t normally blog book reviews – mostly because it requires a specific skillset that I do not necessarily possess. However, due to some fortuitous timing I jumped on the chance to receive a review copy of Manning’s new title - Continuous Integration in .NET by Marcin Kawalerowicz and Craig Berntson.

Background

One of my many hats right now is version control manager of our team – a role I inherited rather than requested but one that nevertheless led to a deep interest in all things VC and build related. Due to the restructuring of MSDN’s licensing tiers our team is finally in the position to utilize Team Foundation Server as our version control repository. Having successfully sold the migration to the powers-that-be, and having previously started the team down the path to TDD, I’m interested in leveraging a number of incorporated technologies – at the very front of the pack is Continuous Integration. Our shop has never had a CI process, but that is about to change.

Warning

The version of this book I read is a MEAP (Manning Early Access Preview) meaning that it is not the finished product. Specifically, and sadly, the final chapter Scaling Continuous Integration is not complete at this time. My review is of what is available as of 9/20/2010

My Expectations

· Explain why we need Continuous Integration

· Define the basics

· Go through full setup and lifecycle

· Provide tips and tricks for advanced scenarios

· Provide advice based on real world experience

The Book

Continuous Integration in .NET as expected starts out with an introduction to Continuous Integration, explaining in simple terms why it is needed and how it can be used. The notion of source control is introduced and then a manual automated build is illustrated showing how one, if they so desired, could do the grunt work to set up a trivial automated build. The 4th chapter, Choosing the Right CI Server, is where the real meat begins and the rest of the book deals with integrating commonly used technologies – unit testing frameworks, deployment tools, documentation generators, etc. – with the CI tools of choice.

After reading this book for a little while it hit me that the Continuous Integration itself is little more than an aggregation of other technologies and mechanisms, bundled together towards the common goal of automating tasks that may not otherwise receive the attention they deserve. The book acts as a 100 foot view of Continuous Integration in .NET environments. The authors do not choose a specific CI tool, but instead use Team Foundation Server, TeamCity and CruiseControl.NET, evolving their CI process by adding new steps as the book progresses. I really enjoyed the comparison of these CI servers and, while concise, it highlighted well the reasons to choose one over another. I’d like to have seen a few more thrown in for good measure but, frankly, these seems to be the big players anyway so I’m probably being picky.

The book’s greatest strength is probably also its greatest weakness – the huge scope of CI, coupled with the use of 3 CI servers, means that generalization is preferred to specialization and the book covers MANY of the basic tenets of CI, but does not delve very deep into any one topic. This is not a criticism of the title – it appears to be an explicit tradeoff that the writers made and was not unexpected. By the end of the book a novice should know exactly what CI is, the different types of automated builds available to them and integrate everything from email notifications to unit testing to code analysis…and then some. The book is easy to read and never feels overly technical (perhaps because of the content material) and I found it very accessible. If, despite my grogginess, I can read a technical book on my morning train ride to work, then it deserves some credit!

Because I am already very familiar with Version Control, Unit Testing, WiX, Clickonce and a number of other technologies in the book I felt myself skimming over a lot of material that would have been useful earlier in my career. I speed-read my way through the sections on unit testing and found that there while the authors did a good job of explaining how to integrate such testing into one’s CI process and have the results displayed through the CI GUIs, most of chapters 6 & 7 were wasted on me. I’d like to have seen more real world information and definitely some gotchas based on industry experience. Unfortunately such information was not contained in the MEAP version I read.

Interestingly I would love to give a copy of this book to (junior) newcomers on our team. Not only does the book provide an excellent description of the ins and outs of CI but it also explains in detail a large number of best practices in the software industry today and illustrates practical approaches to implementing them.

All-in-all this was a good book, definitely worth reading. It hit about 3 of 5 of my expectations (listed above) and as a precursor to my first foray into the world of CI it was useful to get a lowdown on the CI options available to me and guides to hook up other technologies to these CI servers. I’d definitely recommend the title to newcomers to CI and also to those interested in related technologies. However, if you’ve already leveraged CI, or are proficient with Unit Testing/Code Analysis/etc. the value you derive from this book may be a little more limited.

TFS – XSLT to transform VSSConverter to Project Creation Settings File

2010-09-19T01:19:00.001-05:00

For the last few weeks I’ve been spending a decent portion of my time (jointly) planning and testing my team’s migration from VSS to TFS. While I’m a big fan of Microsoft’s development platform I’ve been pleasantly surprised at the simplicity of the migration process. Visual Studio 2010 brings with it a command line application called VSSConverter which takes an XML file and completes transfer of code and history with almost no input…almost! The file looks like this:

<?xml version="1.0" encoding="utf-8"?>
<SourceControlConverter>
  <ConverterSpecificSetting>
    <Source name="VSS">
      <VSSDatabase name="C:\TFSMigration\vss_database"></VSSDatabase>
      <UserMap name="c:\UserMap.xml"></UserMap>
    </Source>
    <ProjectMap>
      <Project Source="$/BillingProject/BillingProject/Client" Destination="$/BillingProject/Client"></Project>
      <Project Source="$/BillingProject/BillingProject/Server" Destination="$/BillingProject/Server"></Project>
    </ProjectMap>
  </ConverterSpecificSetting>
  <Settings>
    <TeamFoundationServer name="myserver.mydomain.com" port="8080" protocol="http" collection="tfs/MyProjectCollection">
</TeamFoundationServer>
  </Settings>
</SourceControlConverter>

One frustration I have with the tool is that, while you must define your VSS-to-TFS project mapping, TFS projects are not automatically created – they must be created one-by-one using Visual Studio prior to migration. If you have a large number of projects (which we do) this can be quite frustrating (increasing exponentially with every test iteration run).

Fortunately, TFS’s powertools provide a mechanism to create projects based on a setting file. The command is as follows:

TFPT createteamproject /settingsfile:1.xml

Unfortunately a) it cannot use the existing information in the TFS conversion scripts and b) a separate setting file is required for each project to be created.

To save some time I wrote the following XSLT file. Applied to a VSS-to-TFS conversion file it will output an individual xml file for each project defined therein (filenames are incremented – 1.xml, 2.xml, etc.). Obviously some settings (TFS server/process template/etc.) are hard-coded and may need to be modified.

<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet 
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
  version="2.0">
<xsl:output method="xml" indent="yes"/>
<xsl:template match="ProjectMap">

<xsl:for-each select="Project">
<xsl:variable name="filename" select="concat('output/',position(),'.xml')" />
<xsl:value-of select="$filename" />  
<xsl:result-document href="{$filename}">
<Project xmlns="ProjectCreationSettingsFileSchema.xsd">      
        <TFSName>http://mytfsserver:8080/tfs/myprojectcollection</TFSName> 
       <LogFolder>c:\temp</LogFolder> 
       <ProjectName><xsl:value-of select="substring-before(substring-after(@Destination,'$/'),'/')"/></ProjectName> 
       <ProjectSiteEnabled>true</ProjectSiteEnabled> 
       <ProjectSiteTitle><xsl:value-of select="@Destination"/></ProjectSiteTitle>                  
       <ProjectSiteDescription></ProjectSiteDescription> 
       <SccCreateType>New</SccCreateType> 
       <SccBranchFromPath></SccBranchFromPath>                 
       <ProcessTemplateName>MSF for Agile Software Development v5.0</ProcessTemplateName> 
</Project>
</xsl:result-document>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>

I personally use Saxon to transform my conversion file – both because it is quick and easy and because, unlike MSXSL it supports XSL 2.0). Afterwards I can use the TFPT createteamproject command to create my projects. The commands used are as follows:

Saxon\Transform.exe -s:conversion.xml -xsl:transformer.xslt

TFPT createteamproject /settingsfile:1.xml

TFPT createteamproject /settingsfile:2.xml

On a side, it should be straightforward to create a batch/powershell script to loop through the XML files and invoke the TFPT createteamproject command, but I’ll leave that to you, dear readers. Let me know if this is useful or if there is a quicker and easier way to achieve the same goal. Until next time…

Upgrading to ASP.NET MVC 3 Preview 1

2010-07-27T20:27:00.001-05:00

Earlier today Scott Gu announced the availability of ASP.NET MVC 3 Preview 1. This release includes the beginnings of the Razor view engine as well as a bevy of additional features. The following are some notable links with more details:

Anyhow, I played with the demo and got to wondering how to update an existing ASP.NET MVC 2 project to use the new preview version (obviously I wouldn’t switch production code any time soon…)

It was simply a matter of editing my existing ASP.NET MVC 2 (C#) project file and making the following updates:

ProjectTypeGuids

Replace

{F85E285D-A4E0-4152-9332-AB1D724D3325}

With

{E53F8FEA-EAE0-44A6-8774-FFD645390401}

and

References

Replace

<Reference Include="System.Web.Mvc, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL" />

with

<Reference Include="System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL" />

Reloading my project I can confirm that everything builds nicely and I know have the additional option of creating a razor view as in the blow screenshot:

Simple stuff!

[Edit]

Looks like I missed a step. I also had to make a minor modification to my Web.Config file replacing:

<dependentAssembly>
<assemblyIdentity name="System.Web.Mvc" PublicKeyToken="31bf3856ad364e35" />
<bindingRedirect oldVersion="1.0.0.0" newVersion="2.0.0.0" />
</dependentAssembly>

with

 <dependentAssembly>
 <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" />
 <bindingRedirect oldVersion="1.0.0.0-2.0.0.0" newVersion="3.0.0.0" />
 </dependentAssembly>

"$.validator.methods[method] is undefined"

2010-07-26T01:05:00.000-05:00

I’ve started developing a new project and have recently been getting into ASP.NET MVC and JQuery a lot more. To make my life easier I decided to use the JQuery Validation libraries to perform my client side validation. I created a simple registration form with three fields – username, password, confirm password. The following is the code I am using:

The code uses a remote call to the IsLoginAvailable action of the user controller which in turn checks if the entered username has already been taken and wraps the response in a JsonResult. This appeared to work fine (validating the field when focus was lost) but upon submitting the form I received the following error:

"$.validator.methods[…] is undefined"

or

"$.validator.methods[method] is undefined"

After debugging with Firebug I found that the validation was failing on a "data" method. Looking at the code I realized I was specifying the username to pass via the data section in the remote call – this was something I picked up in the examples online and assumed I too would need to use – shame on me!

I removed the data section from my remote call and lo-and-behold everything worked as it should. I was surprised to see that my #username value was passed correctly to the controller action and the check was performed successfully. Better still, upon submitting the form I no longer receive the "Error: ‘$.validator.methods[…]’ is null or not an object" error...now to figure out why I would or wouldn’t need the data section!

ASP.NET MVC – Object Reference is not set to an instance of an object

2010-07-23T14:07:00.000-05:00

In the end I have to chalk this down to incompetence and one of those frustrating error messages that tell you absolutely nothing.

I’ve been working on an ASP.NET MVC application and last night decided to use JQTouch to provide an iPhone/Android mobile interface. Doing so should have been extremely straightforward. The planned steps were as follows:

Add code in my base ViewEngine to detect if a mobile browser is being used. If so, provide a mobile view rather than a standard one.

Create a number of views that use the JQTouch library to format my pages for mobile devices.

I recently came across the Mobile Browser Definition File on Codeplex which can be dumped in the app_browser folder in an asp.net solution in order to provide a bunch of information through Request.Browser. I dumped this into my solution, updated my view engine and implemented a few views with JQTouch. It didn’t take too long and i was feeling pretty good. However, attempting to open my application I received a very generic error:

Object reference not set to an instance of an object

As shown in the below screenshot, not only is the message completely useless, but no source file or code line is specified.

I debugged for ages, but couldn’t even break in the global.asax file – so couldn’t step through the code to see what was going on. I subsequently tore my code apart, and after a full rollback realized that the mobile.browser file that I had dumped in my app_browser folder was causing the error.

Removing this file allowed my application to run, re-adding it caused the message to re-appear. After a little googling I found the root cause – browser files can no longer go straight into the app_browser folder – they must go in a sub-folder…any sub-folder. Had I looked a little closer I would have seen the following on the MDBF FAQ page and saved myself a ton of time and frustration:

Why am I getting "Object reference not set to an instance of an object."?
If after copying the .browser file into your AppBrowsers folder you get a compile error “Object reference not set to an instance of an object.” and you have .NET 3.5 SP1, then the issue is likely that you must create a sub-directory (of any name) in your AppBrowsers folder and place the .browser file in there. E.G. \App_Browsers\MobileBrowserData\mobile.browser

And now all is back to normal

VS2010 Power Tools Extensions are AWESOME

2010-07-20T20:59:00.001-05:00

This morning on my daily commute to work I read ScottGu’s latest post detailing the latest round of updates to the VS21010 Productivity Tools extensions. I’m always excited to look at new (or improved) tools that can have a positive impact on my development work and have been very impressed with the powertools thus far. I’m not sure if it is a function of Visual Studio’s extension engine overhaul or simply coincidental, but a lot of really neat new extensions have already been developed for 2010 and to date have been much more useful than their 2008 counterparts.

The powertools are a free extension and worth every penny! They contain such gems as Ctrl+Click to go to definition, Triple Click to select a full line of code, Colorized and orderable tabs, and a whole lot more. Today’s update blows all of that out of the water.

Mr. Gu went into detail so I’ll keep this short. While there are a bunch of new features in the latest release I am super-excited about additions to the solution explorer (in the form of a new solution navigator) in the latest revision (and will focus on these). I’d expect to see these in Coderush or Resharper – not in a free extension – and I seriously believe that my productivity will increase as a direct result of these updates.

1. View Classes and Members in Solution Explorer

I didn’t know I needed this until today but files in the solution explorer are now further expandable, allowing types, methods and even members to be viewed in the tree. This is pretty sweet and one less context switch to get where I’m going.

2. Searchable Solution Explorer

You heard me right – you can now enter search terms in Solution Explorer! And it works ever so well! Searches will find terms in project names, file names, type names…down to member names. It is fast (even for a couple of large projects I played with) and makes finding what you are looking for super easy.

3. Selectable Root

Solution Explorer can often be overwhelming – especially for big solutions with many projects and deep source trees. This update adds the ability to choose what project/folder/file you want as the root. In the below example I’ve chosen the jni4net.n.10 project as my root. Everything else is hidden and I can focus on only the code I want to see.

Similarly, if I wanted to see only that beneath adaptors I would click the little icon (highlighted) on the right and end up with the view below. Seriously, do you ever remember your solution being so uncluttered? The two icons (highlighted) on the top left are used to go up a level or back to a previous configuration.

While I love the new search capabilities, this is by far my favorite of the new additions. This is the developer’s equivalent to a pair of blinkers!

4. Additional Filters

Last but not least (for this post) is the addition of a number of filters (All/Open/Unsaved/Edited) which allow the Solution Explorer to be filtered to show only files that are currently of interest. Below I’ve chosen Unsaved and see that I have been working on (but am yet to save) one file – Out.cs. Not a big deal, but one that could be useful nonetheless.

Summary

While there is no doubt that Microsoft develops amazing software it often feels like we get a big release once very two or three years and have to be happy with our lot for a few years until we get to the new release. This feels different – more akin to the community driven approach of many OSS projects where the updates are added and codebases refined continually. This is an awesome piece of software and a must-have addition to Visual Studio. It really increases the value of the tool and, no doubt, the efficiency of the developer wielding it! I love it!

Napkee

2010-07-20T13:15:00.000-05:00

Recently I blogged about my experience with a neat wire-framing tool, Balsamiq Mockups. To recap, I loved (and continue to love) the tool with the exception of one design decision - intentionally keeping the tool rough and low-fidelity. Shortly after publishing the post I received a comment asking if I had tried Napkee for HTML wireframe conversion…Following the Anonymous poster’s lead, I managed to procure a review copy of Napkee and am happy that I did. To answer the obvious question: no, Napkee isn’t exactly what I was looking for. But its not far off!!

Balsamiq/Napkee Affiliation

There does not appear to be any official affiliation between the Napkee and Balsamiq teams, however the following 2009 Balsamiq blog post does suggest that Balsamiq are open to building a community around their open bmml standard – starting with Napkee:

http://balsamiq.com/blog/2009/08/05/napkee-launches/

Overview

Napkee, as its website says, lets you export Balsamiq Mockups to HTML/CSS/JS and Adobe Flex 3. In essence it is a post-processor that takes bmml files and turns them into web or desktop apps. In my post on Balsamiq I “implore[d] the Balsamiq team to introduce a post-processing feature that turns a wireframe mockup into something that actually looks like a real screen”. This is precisely what Napkee has done. While I would like to see a third mode (adding to the existing HTML and Flex support) that generates static image files (PSDs would be nice) rather than interactive content.

As is Napkee has fulfilled my wish to turn Balsamiq mockup files into something more presentable – specifically something that could be presented to a project sponsor or client.

Converting a Mockup

The process of converting an existing mockup to HTML/Flex couldn’t be more straightforward. The UI is extremely simple with very little required interaction. Importing a bmml file is a two step process (File->Import Balsamiq Mockup Files) at which point the file is processed and converted to the project nature of choice (see the big WEB and FLEX 3 buttons on the top right hand side?).

I created a new Napkee project named Mockups for Blogpost and added the same datagrid used in my Balsamiq post. The below screenshots show how Napkee converts these controls to HTML and Flex respectively.

The Preview pane is fully interactive so if there is a control on the page (for instance, the Flex datagrid is sortable and has a scrollbar) one can immediately test how these controls react to user input. You’ll notice that there are multiple tabs beside the preview tab - HTML/CSS/JS/BMML for web mode and MXML/AS/BMML for flex mode. These are (sadly) read only views where you can see the markup (and existing bmml) for your mockup. While it is probably outside of the scope of the application, it would be great if these tabs acted as editors for the relevant source files, allowing HTML/CSS/etc. to be tweaked within the application and saved as part of the project.

While it seems like a trivial point, I love that markup is broken out into separate files. It may stand to reason, but I can’t count the number of code generation tools I’ve seen that package up all source code into a single unholy mess of a markup file. Kudos to Napkee for being developer friendly here.

Exporting a project is as simple as clicking the novelty-sized Export Project button in the mockup files menu on the bottom-left of the screen, resulting in a well structured folder containing the newly generated source files.

One feature that I’m a little disappointed by is the ability to provide additional CSS files to the project. Ideally this would give the user the ability to customize the output HTML with their own CSS styles. It works…to a point. The problem, in so far as I see it, is that there is no obvious way to remove the existing CSS styles – i.e. you cannot tell Napkee to provide only raw HTML. When I added my own CSS styles some were overridden by Napkee’s styles leaving me with an ugly matrimony of styles. This isn’t a dealbreaker by any means, but I’d love to see it addressed and am guessing it would be a relatively simple change.

More Advanced Mockups

Mockups To Go is still a great source of Balsamiq mockup templates and, to put Napkee through its paces I downloaded two of the larger templates and converted both into Web and Flex pages.

Facebook Fan Page

Original Balsamiq Mockup

Napkee Web

Napkee Flex

Wordpress 3.0 Beta Admin Comment List

Original Balsamiq Mockup

Napkee Web

Napkee Flex

As you can see in the above images I have highlighted in yellow some major discrepancies between the originals and the web/flex counterparts. Most of these are in the form of inconsistent layout and, in the case of the flex conversion, fields whose markup was not converted at all. While this sample size is way too small to definitely point to a problem with Napkee itself, it definitely looks like the bmml processor needs a little work.

That said, there may be cases where the Balsamiq mockup was created outside of recommended practice. Take, for instance, the yellow row in the Wordpress mockup. Rather than a colored row, it looks like a yellow rectangle was placed right on top of the grid to give the illusion that the row is colored. In this and other cases Napkee can only convert what it sees and the tool cannot be blamed for bad implementation. Garbage in garbage out, so to speak…

In Summary

Napkee has no learning curve whatsoever and converts Balsamiq mockups to their prettier and more functional form without requiring any thought or real effort. As complexity of mockups increases Napkee’s results become somewhat of a mixed bag and it appears that the bmml processor could do with some updates to its layout algorithms. However, when it works it works really well and all-in-all I think the tool is a great addition to Balsamiq Mockups. At $49 it is relatively inexpensive and if you charge by the hour will probably pay for itself pretty quickly. I, for one, look forward to seeing how Napkee improves and evolves over time.