So I spent 1/2 hour just to find out that their software can't be used yet. How about creating a better user experience???

If the software is sold 2 months before it can actuyally be used, why not tell customers UPFRONT??? At the very least, the error message could be a bit more informative. Even the site the error message referred me to said the forms where available!

Here is the Chat log (keep in mind each answer from the friendly support person took several minutes):

You have been connected to Rene P.
Rene P: Hello Michael, welcome to H&R Block At Home Live Chat Support! Please allow me a few moments to review the information you have submitted to us.
Rene P: To ensure I understand you correctly You selected to create a new return for C corporation and you receive a error message that says federal interview is not installed. Is that correct?
Michael van der Meulen: that is correct
Rene P: Ok The software you are using is premium for which computer Windows or Mac.
Michael van der Meulen: Windows
Michael van der Meulen: I'm using H&R Block Business 2012
Rene P: Did you buy your software online or at a retail store?
Michael van der Meulen: Retail
Rene P: What stare are you from that you are trying to create the return.
Michael van der Meulen: Florida
Rene P: One moment while I look up the information for you.
Rene P: I am going to provide you with some steps to update the program let me know what happens at your end.
Rene P: Open the H&R Block At Home Business program.
Click on the Forms menu across the top of the screen, move to the Update H&R Block Business menu and then select one of the following:
All Federal Forms to update all federal forms.
The specific form for a quicker update.
Once they receive a message letting that the process is complete, re-start the program.
Michael van der Meulen: I had already done that (see my initial message), but I did do it again. The result is still the same: "Federal Interview is Not Installed"
Rene P: I see Ok Is there a specific form you needed for the C Corporation return?
Michael van der Meulen: 1120 - And it's showing as installed
Rene P: There is one more thing I want you to do for me and I thank you for being patience go ahead and go to this website for me.
Rene P: http://www.hrblock.com/tax-software/download-updates.html
Michael van der Meulen: WHat do you want me to downlod?
Rene P: No. Go ahead and click form update under the business tab
Michael van der Meulen: I copied the downloaded file to C:\Program Files\H&R Block Business 2012\NewFiles and restarted HR Business 2012 and I'm getting the same result: "Federal Interview is Not Installed"
Rene P: There been a lot of customer that are having this problem and I just been advised from my supervisor that the reason you are getting this error message is because the tentative date for the business is scheduled until the February 4th.
Rene P: The reason being is because most of the forms are still not available until that date.
Michael van der Meulen: That is not what the Forms Release Dates shown at http://taxcut.atxinc.com/taxcutformsstatus.aspx - I can't afford to wait until February 4h just to find out that it's still not working.
Rene P: I do apologize for this issue that you are having but I am seeing a list here that the date scheduled for business is until February 4th> What you see on the form release date are only a portion of the list that is ready to use.
Michael van der Meulen: So, in other words, the software I bought is not working until at least February 4th?
Rene P: Yes that is correct
Michael van der Meulen: Is there other software that works today?
Rene P: Yes all the other software Basic, Deluxe, but not the business.
Michael van der Meulen: How about your competitors' software for business?

OK, this is probably not very informative, but I have to complain about the state of today's documentation, in particular, Microsoft's documentation.

We see tons of new technologies produced by Microsoft (and others), and published, tweeted, blogged about all over. Focusing just on the .NET "stuff", the amount of documentation is huge, but the quality is abysmal.

C#, VB.NET has had XML Comment Tags for nearly a decade now:

''' 

''' Returns the number of times Counter was called.
''' 
''' Number of times Counter was called.
Public ReadOnly Property Counter() As Integer
    Get
        counterValue += 1
        Return counterValue
    End Get
End Property

We have had tools like SandCastle also for years.

Before these tools became available, documentation had to be written from scratch, often the developers would collaborate with a tech-writer and produce documentation like this http://msdn.microsoft.com/en-us/library/ms682425(v=vs.85).aspx. This example is from the Win32 API documentation. It looks fairly complete, the purpose of the function is clearly explained, all parameters have explanations and the Remarks section offers additional usage information.

One would expect that tools like XML Comment Tags and SandCastle would tremendously improve documentation. The documentation can now be automatically generated based on comments the developer leaves with the source code. The formatting and presentation can still be controlled by tech-writers.

Unfortunately human nature (or laziness) prevails and we end up with decent looking, completely unusable documentation.

Case in point, here was an apparently particularly lazy programmer at work or he/she assumed everyone is a mind reader:

http://msdn.microsoft.com/en-us/library/system.web.webpages.scope.scopestorage(v=VS.99).aspx

As of 1/26/2011 it is impossible to find out what the purpose of the ScopeStorage class is. This class happens to be used in MVC 3 (a released feature), so I have to assume @haacked, @scottgu, et. al., somehow found out what the purpose of the class is - probably some form of internal Microsoft-only mind meld. In this simple, small class the purpose can be derived from the MVC 3 source. It handles web.config <appSetting>. It sure would be nice if the documentation actually mentioned that.

No matter how good your product, code or API is, if we can't find out what it does, how to use it or that it's even available, you might as well save your time and not develop it. If our only source of documentation is someone else's source code, a blog or a tweet, it's useless. 

Some of you may have noticed that WEOReport.com wasn't developed using DotNetNuke. And you may know that I'm an avid DotNetNuke supporter. I try to attend the Orlando DotNetNuke user group meetings regularly (actually, that has become a lot easier since I moved to Orlando). Or, you may have used my DotNetNuke installer.

In any case, I started development of WEOReport.com a while ago, using DotNetNuke. I got side-tracked by MVC - big time. As a developer, I was immediately intrigued by its approach to web applications. Since I started developing web applications back in 1995, when the Internet was in its infancy, using Perl along the way, I never quite bought into the "let's-pretend-web-applications-are-not-stateless" approach of ASP.NET.

Even though using C# and Windows Forms applications was second nature to me and the similarities to ASP.NET were undeniable, knowing how behind the scenes things are totally different was always a turn-off. Along came MVC and my interest was peaked. Request - Response, no state, pure and simple. Admittedly, MVC is probably not the most productive environment at first, but it has its advantages.

With DotNetNuke on my mind, I set out to produce something that covered my needs but tailoring it to match my needs exactly. I still use DotNetNuke for a few sites (like softelvdm.com). And that's unlikely to change. DotNetNuke is one heck of a CMS, with many features and advantages. I initially started developing WEOReport.com using DotNetNuke. But there were some areas that always bothered me when developing larger projects with DotNetNuke. First, as a framework, it actually does fairly little to support my module development. Don't get me wrong, I understand that there is a sizable base class responsible for my module's functions. I'm referring to things like Settings or property pages. I have to create each one. Since modules in DotNetNuke are just User controls, why not build property page support for modules right into DotNetNuke.

In theory, DotNetNuke could determine all my module settings from public properties that my modules expose. This would result in automatic settings for every module. No time wasted on routine stuff. That is what a framework should be in charge of. Taking care of routine task so I don't have to.

Then, the multi-layered approach in DotNetNuke (data layer, business layer,etc.) causes much duplication (if I want to use the same approach) and again, routine stuff, I have to implement.

Dealing with large sets of modules in a "package", I never quite figured out how to manage this properly in DotNetNuke, so it appears as one package, rather than just a bunch of modules. That may be due to my lack of research into this area.

Along came MVC, and it offered an alternative to ASP.NET's lousy HTML generated by its controls (not DotNetNuke's fault at all), its true statelessness which I readily appreciate and a few other notable features (which are now also available in ASP.NET 4).

Since MVC came along at just the right time and I was hitting a few (truly minor) road blocks with DotNetNuke, I got side-tracked into developing my own web framework. I call it Yet Another Web Framework or YETAWF (if you know what YACC is or stands for you'll understand where I got this from). It uses the same "module" idea as DotNetNuke - kind of an MCMV approach (Module/Controller/Model/View) - And a module exposes properties which the framework interprets and it offers property pages (so I don't have to implement them). I have also implemented very tight integration with Visual Studio. I can create a new group of modules offering Browse, Edit, Display, Add, Remove features for a dataset within seconds. YETAWF focuses on rapid application development, granted, tailored to my needs rather than thousands of users.

I could have done all this in DotNetNuke and it probably would have ended up looking the same and would have taken the same amount of time. For this particular application and my desire to learn and use MVC using a truly custom approach worked out great. Does this mean DotNetNuke couldn't have stepped up to the task? Absolutely not! DotNetNuke would have been an equally suitable platform. But hey, I'm a developer, and I'm not "married" to a specific technology. I like to try things. Once I stop, start worrying...

I hate my laptop - actually, every laptop I ever owned or used. I spend most of my time working on desktop systems and rarely need to be on the road, so working on my laptop is quite rare. Every time I do, I spend half my time complaining about the keyboard. The reason? I hit the Caps Lock key when I need the Shift key and I hit the Windows key instead of the Alt key.

I always felt that the size of a key should be proportional to its usefulness. The Caps Lock key for example is such a relic from times gone by. Actually, I don't think I ever used it not even when I worked on mainframes (yes I'm over 40 :-). Maybe people who have the need to "shout" in forums need the Caps Lock key. Why don't they make special "Troll" keyboards or "DNFTT" keyboards (you're a fellow geek if you know what that means).

And what about that silly Windows key? What is that all about? Yes, I read this. Maybe if I could remember any of the shortcuts I might use them: <sarcasm> Win+Pause is really useful to open System Properties </sarcasm> IF I USED IT OFTEN!!! (Oops, I could have used the Caps Lock key here, but I forgot).

Anyway, I said I fixed my "fat fingers". Well, I'm still a lousy 6 to 8 1/2 finger typist who constantly hits the Caps Lock and Windows keys (even on my desktop). But, I found a simple registry fix that takes care of my problem. The Caps Lock key becomes another Shift key, so I don't even notice when I miss the "real" Shift key.

I combined two different registry fixes (here and here) into one. The whole registry bits are explained nicely in the first link (my source of information) if you're interested in the details. Here is the whole "magic" (or download and run it from here):

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]
"Scancode Map"=hex:00,00,00,00,00,00,00,00,04,00,00,00,2a,00,3a,00,00,00,5b,e0,00,00,5c,e0,00,00,00,00

You'll have to reboot after applying this registry update.
 

Normally, dealing with Internet Explorer is painful for anyone having to design or skin a site and, like everyone else, I usually don't enjoy dealing with browser incompatibilities. I thought I was well shielded from IE as I was just writing some code today, working on some browser independent stuff. Or so I thought.

I had to display a text file, which happened to contain HTML. Simple enough: set the ContentType to text/plain and display the content. Not so fast! Internet Explorer 8 kept displaying it as a web page. I tried reasoning with it but it just ignored me. Then I showed Internet Explorer that Chrome could do it correctly. Chrome dutifully obliged and displayed my text data. IE was not impressed, even when I brought reinforcements, Safari and Mozilla.

So there I was, feeling abandoned and bullied at the same time. Google to the rescue! Sure enough, I found an old bug report on Microsoft's site (http://support.microsoft.com/kb/329661) linking to another entry documenting a Registry hack and a fix that supposedly is available upon request. This KB article has this disclaimer "This article was written about products for which Microsoft no longer offers support. Therefore, this article is offered "as is" and will no longer be updated." Funny thing is, IE8 is supported, so Microsoft must have decided in their wisdom, that this is the way things must be. Or maybe they're busy fixing real problems, like CSS support, HTML5 or whatever.

It's not difficult to work around the problem (just like all your CSS hacks!). For IE, change the headers by adding Content-Disposition so the data is opened/saved rather than displayed as direct content, as in:

public ActionResult DisplayHtmlSource(long reportItemID) {
    ReportItem reportItem = ReportItem.VerifyReportItemID(reportItemID);
    HttpBrowserCapabilities caps = System.Web.HttpContext.Current.Request.Browser;
    if (caps.Browser == "IE") {
        HttpResponseBase response = ControllerContext.HttpContext.Response;
        response.AppendHeader("Content-Disposition", "attachment;filename=\"Text.txt\"");
    }
    return Content(reportItem.PageInfo.RawHtml, "text/plain");
}

It's not earth-shattering, but really, I did not need this "distraction" on my to-do list. You do wonder who comes up with these "design ideas" that seem of little value and who decides not to fix them.

Today I was struggling to get a fairly simple query to work in my current project. While I was using LINQ to SQL for this portion, in other parts I use my own home-grown model to SQL translation, based on stored procedures, generated from the model's DataAnnotations. LINQ to SQL gave me a bit of a problem with the last grid display before the project was completed.

I had a fairly benign query involving 4 tables (all inner join), using group by, order by and some aggregate operators (mainly Count()). While I had no problem expressing this with LINQ, introducing an anonymous type here or there, the runtime really was not all that good (well, that's being polite - in fact I was cursing quite a bit).

Remembering Mitch Labrador's BigfootSQL that he presented at one of the recent ODUG meetings, I started to investigate it as I always was partial to the approach embodied by BigfootSQL. Rather than being yet another API layer, BigfootSQL is nothing more than a set of "convenience functions" giving direct access to the SQL query. While this description really doesn't do its usefulness justice, it handles some of the "administrative" tasks for you, like parameter handling, and it can hand you a full set of objects, retrieved through a query, while you (the developer) have complete control over the query.

Here is a small example of a query that I'm using. BigfootSQL  even has support for paged record retrieval. As I was debugging my application (and learning BigfootSQL at the same time), it became obvious that this is the way to go, retaining complete control over the generated SQL, enhanced with some handy helper functions, like ExecuteCollection() in this example, that reads the requested records and returns a list of objects (List<UserSiteSpellingError> in this example).

public static List<UserSiteSpellingError> GetSpellingErrors(out int totalRecs, long reportID, 
                     ref int currPage, int pageSize = 20, 
                     string sortField = null, string sortOrder = null) {
           
  DefaultSortAttribute.GetSortOrder<UserSiteSpellingError>(ref sortField, ref sortOrder);

  BigfootSQL.SqlHelper DB = new BigfootSQL.SqlHelper(YourConnectionString);
  DB.Clear();
  List<UserSiteSpellingError> list =
    DB.SELECTPAGED("ReportErrors.Data1 As Word, Count(*) As Count, 2 As MessageType", 
         sortField + " " + sortOrder)
      .FROM("UserReportErrors")
      .INNERJOIN("ReportErrors ON UserReportErrors._ID = ReportErrors._ID")
      .INNERJOIN("Messages ON ReportErrors.MessageID = Messages.MessageID")
      .INNERJOIN("ReportItems ON ReportErrors.ReportItemID = ReportItems.ReportItemID")
      .WHERE("Messages.MessageKind", 2)
        .AND("UserReportErrors.Suppressed", 0)
        .AND("ReportItems.ReportID", reportID)
      .GROUPBY("ReportErrors.Data1")
      .PAGE(currPage - 1, pageSize)
      .ExecuteCollection<UserSiteSpellingError>();
    totalRecs = DB.GetParamValue<int>("SELECTPAGED_TOTALRECORDS");
    currPage = DB.GetParamValue<int>("SELECTPAGED_PAGE") + 1;
    return list;
}

I added some functionality to BigfootSQL (and fixed a thing here and there as the source code seems a bit behind the dll?). For example, my paging requires that I receive the total number of records and the page actually displayed (important as data is subject to outside changes). Since BigfootSQL includes the source code (thanks Mitch) it's easy to adapt it to your requirements. In this case, I added bi-directional support for parameters (like "SELECTPAGED_PAGE") so I can retrieve updated values after a query.

If you are like me and like to retain control, BigfootSQL may well be the way to go!

Really, I never paid much attention to Search Engine Optimization other than the basics.

But when I designed and implemented this site 1 1/2 years ago, I decided to intentionally ignore all SEO tricks and tips that people commonly publish. Worse, I decided to deliberately do things really poorly. I was just curious to see if it really made a difference.

First I use a Flash menu and a Flash header. Then, the site was using DotNetNuke until about 2 months ago, with just a small menu at the bottom of the page. Of course, along with the usual semi-giant ViewState and non-W3C compliant HTML.

I noticed that my blog entries were poorly indexed by Google and overall the site ranked very low on searches, even for fairly specific keyword combinations, which I would have expected to perform better. Even with my deliberate attempts to break SEO, I would have expected a bit better results.

As I was working on my little MVC project, I decided to convert this site to ASP.NET MVC, blog and all. It still looks the same and acts the same, same skin, same Flash menu and same deliberate SEO mistakes. But, I dumped the ViewState, cleaned the HTML to be fully W3C compliant and use compression to minimize the resulting HTML. With just these small changes, I noticed a significant increase in traffic and noticed that particularly the blog entries rank significantly higher and are much better indexed by Google.  

But it does look like just making the content more accessible to Google gives a boost to rankings (well, that is actually as expected as that is one of the recommendations).

Now I wonder how much better things could be if I actually followed SEO recommended practices...

Sometime last year I had an idea for a new product/service, for which I needed to create thumbnail images for web pages. I managed to successfully develop that part but since then, I have been sidetracked by MVC, some Visual Studio 2010 "stuff" and the usual day-to-day work. But I was always fascinated by the little thumbnail images that services like snap.com offer. So much so, that for a while I used their service on my site here.

But, I really didn't like their branding or that people could search and visit other sites from their preview popup. Actually, that is their business model and how they derive revenue from their service. I even contacted them if they had a "pay-for-no-branding" service, but they didn't.

So I set out to "roll my own". Of course I couldn't resist doing this in my current MVC-based web framework. I probably would have been better off implementing it for DotNetNuke, which is what I use for my "real" web sites, but that may still happen.

Here are a few examples of "Preview Links" or links with preview images (just hover with the mouse over the link and wait just a bit):

DotNetNuke.com's Project & Technical Documentation

Templated Helpers

App_offline.htm

It is still a work in progress and I have a few issues to address. Also, this site runs on a fairly cheap, underpowered VPS somewhere in Colorado so there is a bit of a delay (at least for me, I'm in Florida) before the popup fully initializes, but it's still a lot faster than clicking on the link to see the full page.

It turns out that creating thumbnails of web pages is a bit more difficult that just hosting a "webbrowser" control on a form and saving the thumbnail. Mostly because the Windows Forms webbrowser control is fairly brain-dead. In addition, it takes at least 10 seconds to create a reliable thumbnail image under the best of circumstances, particularly if Flash or Silverlight are involved. That is way too long to wait for a thumbnail.

The solution I came up with (surprise, similar to what snap.com does) is to implement a website crawler, started using the scheduler, which every once in a while scans the entire site for links that need thumbnails. Another background task creates thumbnails as new links are found. This same background task also creates thumbnails as soon as a user hovers on a link and no thumbnail is available yet. If you were to comment on this blog and use a link in your comment, once you hover over the link for the first time, a thumbnail to your site would be available within about 30 seconds.

Like I said, I was fascinated by the technology. Overall, it's just a gimmick, which probably only fellow geeks can appreciate. If anyone has any marketing thoughts on this, I would certainly like to hear them.

For years, I always hated updating my sites. Even with DotNetNuke, making changes always meant either making them on my development system first, backing up the database, restoring it to the live site or making changes to the live site little by little - always hoping no one would notice my "work in progress".

With my current MVC project, I found a trivially simple way to do major and even minor updates without letting anyone see a partial update. First off, I have no problem shutting down my site for a few minutes (displaying a suitable status page to visitors) while I update the site. The obstacle was that with a feature like ASP.NET's app_offline.htm page, it locks me out too!

For my MVC projects, I can define a simple action filter that only allows access to the site from my IP address. Anyone else will be redirected to a web page (/App_NOTOffline.htm). That's an odd name, I admit, but it's the name of my App_Offline.htm page while the site is NOT offline (for me).

At the same time, the same action filter happens to redirect all IE6 users (and other older browsers) to a "friendly" page that lets them know that my sites don't support their browser.

This gives me the ability to fine-tune the live website without having visitors potentially exposed to my less than perfect final work. They'll get redirected to my "Sorry, the site is not available" page. Maybe, down the road I'll use a simple website staging mechanism, so visitors get the original site, while I'm working on the new site.

Here is the partial source for the action filter:

protected override void OnActionExecuting(ActionExecutingContext filterContext)
{
    HttpBrowserCapabilitiesBase caps = HttpContext.Request.Browser;
    if (caps != null && !SupportedBrowser(caps)) {
        filterContext.Result = Redirect("/App_UnsupportedBrowser.htm");
        return;
    }
    if (!string.IsNullOrEmpty(SiteProperties.Properties.LockedIP) && HttpContext.Request.UserHostAddress != SiteProperties.Properties.LockedIP) {
        filterContext.Result = Redirect("/App_NOTOffline.htm");
        return;
    }
    base.OnActionExecuting(filterContext);
}

private bool SupportedBrowser(HttpBrowserCapabilitiesBase caps)
{
    switch (caps.Browser.ToLower()) {
    case "safari":
        if (caps.MajorVersion < 4) return false;
        break;
    case "chrome":
        if (caps.MajorVersion < 5) return false;
        break;
    case "firefox":
        if (caps.MajorVersion < 3) return false;
        if (caps.MajorVersion == 3 && caps.MinorVersion < 5) return false;
        break;
    case "ie":
        if (caps.MajorVersion < 7) return false;
        break;
    }
    return true; 
}

SiteProperties.Properties.LockedIP is an external data source which holds my IP address which is saved by other UI code (you'll have to adapt this for your use). I have simple controllers, with which I can turn this on and off by saving my IP address.

Granted, with an action filter you would have to define the action filter for each controller. In my case, I actually derive all controller classes from my base class, which automatically provides this processing, so I don't have to add it to each controller.