AspNetResources.com articles, news and updates

Load Testing vs. Profiling

Mon, 22 Jun 2009 00:00:00 GMT

A fellow geek asked me the other day, “What’s your take on load testing and profiling?” Incidentally, this question comes up once in a while, so I figured I’d explain my position here.

Profiling

Let’s define profiling first:

A profiler is a performance analysis tool that measures the behavior of a program as it executes, particularly the frequency and duration of function calls.

I consider profilers to be absolutely essential tools, yet they are grossly underutilized. We tend to overlook that a piece of code may be fully tested (pick your favorite xDD fad), but may turn out to contain a bottleneck. Bottlenecks are relatively rare, but where they do occur they hemorrhage resources like there’s no tomorrow. Just about the only way to find it out is with the help of a profiler which will break down the duration of each call to help you zero in on underperforming code.

The two most established .NET profilers are JetBrain’s dotTrace and Red Gate’s ANTS. Both are excellent tools from two well-known vendors. My only gripe is that profilers tend to be quite expensive. Too pricey for individuals, although it seems JetBrains added a personal license. As to businesses, you have to explain long and hard why you need a profiler, but the explanation will probably fall on deaf ears of somebody in the purchasing department. Ask me how I know.

Load Testing

This is a completely different beast.

Load testing is the process of putting demand on a system or device and measuring its response. […]

When the load placed on the system is raised beyond normal usage patterns, in order to test the system’s response at unusually high or peak loads, it is known as stress testing. The load is usually so great that error conditions are the expected result, although no clear boundary exists when an activity ceases to be a load test and becomes a stress test.

The idea of load testing is to simulate heavy traffic to how the app performs under stress. Usually, you “teach” it to jump from one page to another by simulating an interaction with a user. The load test records the path and plays it back.

My beef with this approach is that you’re leading your tool down a happy path. Lucky you if you find problems there. Those are easy to fix. Unfortunately, this is not how it happens in real life.

In real life the interaction doesn’t happen at the same pace. It doesn’t follow the happy path. Users will come up with a combination of steps you couldn’t even imagine. It’s impossible to teach a load testing tool what we don’t know!

Load testing has any meaning only if you can answer this seemingly simple question: what does success look like to you? Success in terms of requests/second, bandwidth, number of concurrent sessions (not users!), etc. I’ve never been given a straight answer.

I’ve sat in meetings where numbers where pulled out of thin air. Inevitably, this is where discussions would end. If you don’t have a meaningful success metric, you’re shooting in the dark. You can’t even define what and how you load test something.

Michael Nygard, in Release It! (my favorite technical read of 2008) says this:

Most load tests deliver results after the test is done. Since the data come from the load generators rather than inside the systems under test, it is a “black-box” test.

On the subject of simulating traffic:

Load testing is both an art and a science. It is impossible to duplicate real production traffic, so you use traffic analysis, experience, and intuition to achieve as close a simulation of reality as possible.

Neither are load tests effective at detecting longevity bugs, he argues:

The major dangers to your system’s longevity are memory leaks and data growth. Both kinds of sludge will kill your system in production. Both are rarely caught during testing. […]

These sorts of bugs usually aren’t caught by load testing either. A load test runs for a specified period of time and then quits.

He goes on to suggest a separate environment set up solely to run longevity tests. “Don’t hit the system hard; just keep driving requests all the time.” That’s an interesting change of perspective. Instead, what I usually see is, Let’s load test this thing and then we’ll look at, um, charts.

Apples vs. Oranges

As you see, this is really an apples-to-oranges comparison: two different activities aimed at gaining different insight.

Profiling, to me, is very quantifiable. I can see where I need to improve code. Load testing, on the other hand, is a black box.

My hope is that we can encourage more developers to use and more companies to buy profilers (and that they would become more affordable). A professional developer should have a good profiler in his or her toolbox.

ASP.NET consulting with imagination and passion. Hire me!

IIS7 Resource Kit Rocks!

Fri, 19 Jun 2009 00:00:00 GMT

I’ve never been much of an “infrastructure guy” which is why Microsoft’s Resource Kit books always induced sleep on me.

However, the IIS7 Resource Kit by Mike Volodarsky, et. al., has been a pleasant surprise. A bit repetitive, perhaps due collaboration of several authors, yet concise and thorough. The diagrams are great and the text is easy to follow.

I’ve held out on IIS7 for too long because I just couldn’t grok the integrated pipeline, and how http.sys, W3SVC, WAS, and W3WP all interacted with each other. I’m sure this abbreviation bingo is scary enough to an untrained eye.

In retrospect, I’m kicking myself, “Why haven’t I jumped on the IIS7 bandwagon sooner?!” It’s got so much stuff out of the box which I’ve been hacking by hand in IIS5 and 6!

If you don’t want to read the entire book, at least read Chapter 2 “Understanding IIS 7.0 Architecture” and Chapter 11 ”Hosting Application Development Frameworks.” I consider these chapters to be essential to web developers.

ASP.NET consulting with imagination and passion. Hire me!

Getting to the Bottom of JavaScript Includes

Wed, 17 Jun 2009 00:00:00 GMT

I get frustrated when an outside vendor insists that I include their JavaScript file all the way up in my pages. Usually they want it right in the <head>. I have a couple of issues with that.

I have no control over the responsiveness of your environment

Historically, when your browser encountered a JavaScript include, it would suspend rendering, parse and execute it. Thus every single include slows down rendering and affects the overall perception of responsiveness.

Yahoo’s Best Practices for Speeding Up Your Site, among many other sources, explains the predicament as follows:

The problem caused by scripts is that they block parallel downloads. The HTTP/1.1 specification suggests that browsers download no more than two components in parallel per hostname. If you serve your images from multiple hostnames, you can get more than two downloads to occur in parallel. While a script is downloading, however, the browser won’t start any other downloads, even on different hostnames.

If an outside vendor’s server has a hiccup, I get screwed. I see it, for example, in Firefox when it blocks some ad script. It just sits there forever waiting to render a script which will never come.

If you’re writing a yet another social networking, social commenting, etc, script, please make sure I can include it all the way on the bottom of my page.

Oh, and help you god if you mess up my DOM with document.write. Please play nice. You’re on my turf. My priorities of building a clean and responsive site are higher than yours.

ASP.NET consulting with imagination and passion. Hire me!

If Only They Tested It on Themselves

Mon, 15 Jun 2009 00:00:00 GMT

The company I’m on a contract with has moved to a new building in NYC. Actually, it’s an old building, but fully remodeled. Since day one we’ve all noticed weird “bugs” about the new design which could’ve been easily prevented if… the contractors tried to use the building the way employees would.

For example, if you walk up to a door and don’t know which way it opens, the door is not designed properly. Period.

Another example: employee card scanners. A lot of people wear magnetic badges on the left side of the belt (the other side is taken by a cell phone clip). Why put the scanner so far on the right? And what about those wearing badges on their necks? Yeah, picture it for a second.

My favorite one: elevators. It’s almost funny to see half the people reach the panel with no buttons. Why put buttons on only one side?

Oh, and the can. The can has so many funny snafus that create uncomfortable social “situations.”

If only they tested all this on themselves first… Software construction isn’t that much different. Put yourself in the end-user’s shoes and walk. See if the shoes fit.

ASP.NET consulting with imagination and passion. Hire me!

Message to GEICO: Usability First Please

Mon, 15 Jun 2009 00:00:00 GMT

Seriously, GEICO, how difficult is it to write a regex to accept a policy number exactly as you print it without resorting to the lame “do not include dashes”?

Hang on, lemme help you: \d{4}-\d{2}-\d{2}-\d{2}|\d{10}. Now you can go both ways.

This ain’t about the length of your database field. I couldn’t care less. It’s about improving usability.

You’re welcome. ;)

ASP.NET consulting with imagination and passion. Hire me!

SuperPreview Blew Me Away

Sun, 14 Jun 2009 00:00:00 GMT

A fellow user group attendee pointed me to a preview of SuperPreview for Expression Web (no pun intended). Testing a web site in various browsers has been such a headache over the years! Either you had to install lots of virtual machines (I so don’t recommend running multiple versions of IE on the same box!), or use a paid service which provided you merely a static screenie of the site. Not good for debugging either way.

I gave mad props to Expression Web before. Unlike most Microsoft products, Expression Web simply rocks! But SuperPreview, if implemented as advertised, is going to be BIG. SuperPreview alone will be worth the price of admission.

To save you rehashing of that SuperPreview is capable of, take a look at Soma’s post about Expression Web 3.

I actually installed it in a virtual machine. Doubting Thomas, I am. The thing that surprised me, which Soma’s post doesn’t show, is the IE 8 > IE7 compatibility preview:

Really cool.

“…will be available this summer 2009”. Hmmm, this is going to be a good summer.

ASP.NET consulting with imagination and passion. Hire me!

Slides and Code from Hartford Code Camp 2

Sun, 14 Jun 2009 00:00:00 GMT

A big thank you to those of you who came to my presentation at the Hartford, CT Code Camp 2. A special thank you goes to the organizers and sponsors of the event.

Feel free to grab the slides from my presentation Professional Client-Side Development with Microsoft AJAX Library and jQuery over here. If you need an extra copy of the AJAX Cheat Sheets, download them here.

ASP.NET consulting with imagination and passion. Hire me!

Temporary Fixes Are Permanent Fixes

Thu, 11 Jun 2009 00:00:00 GMT

A somber reminder that temporary (aka “quick and dirty”) fixes almost always become permanent:

/*
* Note: this problem may have been fixed already.
* I stopped using the session array method for handling things.
* This may have fixed it. I’ll test later.
*/

And “later” never came…

ASP.NET consulting with imagination and passion. Hire me!

Geek Marketing Done Right

Sat, 23 May 2009 00:00:00 GMT

Although I’ve been reading his blog for some time, I’ve never met Billy McCafferty. And yet I’m fascinated by his latest brainchild: IT Samurai School.

The front-end is all Flash. I can almost hear voices of discontent over a spinning this, a swooshing that. Or even, “Oh, no Silverlight?” (get a reality check!) Implementation details aside, Billy is doing something radically different: creating a consistent message with a vibrant story, built on the imagery of the S#arp Architecture project. In other words, it’s not just geek training. It’s an experience.

That’s damn good marketing and a welcome contrast to the run-of-the-mill, boring training sites droning about ROI and RIA, etc.

Once again, this isn’t about Photoshop, or Flash, or MVC, or what have you. It’s about creating an experience.

ASP.NET consulting with imagination and passion. Hire me!

Visual Studio Full Screen For Presentations

Thu, 21 May 2009 00:00:00 GMT

Visual Studio has one very obvious but little–used feature which helps presentations go much smoother: the full screen view.

Most of the time I see presenters struggle with the Solution Explorer sidebar, dragging it back and forth, back and forth, to get it out of the way. A painful exercise for the presenter and the attendees.

Pssst… Hit Shift+Alt+Enter.

ASP.NET consulting with imagination and passion. Hire me!

Dear Art Director...

Sun, 17 May 2009 18:08:15 GMT

Dear Art Director, I believe you are confused. To prove my point, please answer a simple multiple-choice question below.

On the web, people run:

Photoshop
Web browsers

Hint: the right answer is (b). It’s naive to expect a web page to render with pixel-perfect precision in every browser. It’s impossible and impractical. Your insistence to the contrary is wasting my time.

ASP.NET consulting with imagination and passion. Hire me!

Why Async Pages?

Sun, 17 May 2009 00:00:00 GMT

While reading about asynchronous web pages (Chapter 11 of Pro ASP.NET 3.5 with C# 2008), I came across a great reminder:

It’s important to understand that an asynchronous page is no faster than a normal, synchronous page. In fact, the overhead of switching to the new thread and back again is likely to make it a bit slower. The advantage is that other requests—ones that don’t involve long operations—can get served more quickly. This improves the overall scalability of your site. It’s also important to realize that the asynchronous processing takes place completely on the web server, and the web page user won’t notice any difference—wait times and postbacks will still take just as long.

To rehash an older post of mine on unnecessary parallelism in ASP.NET, the number of threads available to a web app is very limited (~20…25). Ideally, you should process a request and return a response as fast as possible. As Michaen Nygard points out, “shortening the processing time means you can handle more transactions during the same unit of time.”

However, if you hold up a request for too long, e.g. due to a long database read or a lengthy web service call, the thread you’re holding isn’t available to process other requests, nor is it doing anything useful while waiting. You gotta do something about it. This is where it’s worth to consider asynchronous processing.

Take a moment to reread the excerpt above. The important point is that “an asynchronous page is no faster than a normal, synchronous page.” It may be even a little slower due to context switching. The kicker here is the request is moved to another thread pool! The .NET Framework provides a number of APIs for asynchronous file IO, webs services, etc, usually named BeingXxx() and EndXxx(). These APIs use the fascinating feature called I/O completion ports which doesn’t use threads from the ASP.NET thread pool.

The book makes another great point:

Performing simultaneous asynchronous tasks is a good technique when your tasks involve different resources. It’s a bad idea if your tasks will compete for the same resource. For example, a page that performs three database queries at once isn’t a good candidate for simultaneous execution, because you’ll need to open three connections at the same time, which will probably have a negative effect on the overall scalability of your site.

At the end of the day, if you feel you need to add parallelism to your ASP.NET app, think long and hard. In most cases it won’t buy you anything.

ASP.NET consulting with imagination and passion. Hire me!

Two Components with The Same Id AJAX Error

Sat, 16 May 2009 00:00:00 GMT

While debugging a script control written with ASP.NET AJAX, we came across this weird exception:

Sys.InvalidOperationException: Two components with the same id '[....]' can't be added to the application.

The control looked kosher in every respect. Yet we couldn’t understand why the client-side “runtime” was trying to create another instance of this script control on every AJAX call. It’s as if it wouldn’t let go of an old instance before attempting to create a new one.

Looking for a solution in Google, it became obvious there were many various causes of the above exception, but one stood out: make sure you call the base dispose in your script control.

I looked at my dispose method:

dispose : function () {
  delete this._remove$delegate;
  delete this._add$delegate;
}

Duh! It should’ve looked as follows:

dispose : function () {
   delete this._remove$delegate;
   delete this._add$delegate;
   [my namespace].[my class].callBaseMethod (this, "dispose");
}

A self-inflicted painful lesson. I hope it saves somebody debugging time.

ASP.NET consulting with imagination and passion. Hire me!

ColoRotate Is Cooler Than Kuler

Sat, 16 May 2009 00:00:00 GMT

Michael Douma sent me a quick introduction to a very interesting project he’s involved in: ColoRotate. In Michael’s own words:

Since color is inherently three dimensional, it’s always bothered us that all color pickers are flat. That led to the design ColoRotate, a 3D editor that aligns with the way our minds process color. We’ve also put together some background information about the nature of color, perception, and color models – http://learn.colorotate.org

A couple of years ago I wrote a post about Adobe’s Kuler. ColoRotate is somewhat similar, but it builds 3D models. Very cool!

ASP.NET consulting with imagination and passion. Hire me!

Rediscovering Nolo

Sun, 22 Mar 2009 00:00:00 GMT

I’m my persistent quest for independent consulting, I have read several books by Nolo. In case you’ve never heard of them, Nolo publishes a wide array of titles for those of us who want to understand legal and accounting mumbo-jumbo. They neither get cutesy like the For Dummies series (those are great in their own way) nor do they sound like law dictionaries.

I think it’s safe to assume that most of you dread the thought of trying to comprehend the myriad of tax regulations and legalities. I’m the same way.

Of course, no book can substitute a professional lawyer or bean counter. But if you want to run your own business (even a freelancer runs a solo business), you have to understand some basics. When you sit down with a CPA to do personal or business taxes, you absolutely need to understand what’s going on. This is where I find Nolo books invaluable!

Recently I read Form Your Own Limited Liability Company, Working for Yourself, and Tax Savvy for Small Business (hence slow blogging). No small books, but well worth the time! My biz IQ is definitely higher now.

Note: I have had a bad experience with Nolo’s software WillMaker, so I don’t know how good their software products are.

ASP.NET consulting with imagination and passion. Hire me!

Book Review: ASP.NET 3.5 / Application Architecture and Design

Sun, 22 Mar 2009 00:00:00 GMT

It is difficult to write about architecture because it’s such a subjective topic. The term itself means different things to different people. Given that Microsoft produces weak architectural guidance, I welcome any and all attempts to hone in on that illusive perfect architecture of a web application. Unfortunately, ASP.NET 3.5: Application Architecture and Design by Vivek Thakur falls short of my expectations.

Let’s step through the book.

Chapter 1. A good discussion of the steps involved in planning a web app life cycle: gatheting business requirements, planning and prototyping, development, release, and maintenance. The chapter also introduces the concepts of tiers (physical separation) and layers (logical separation) and goes on to suggest various tier/layer combinations, e.g. single tier–two layer model, three tier model, etc.

The client’s browser is considered a tier of its own. I tend to disagree with this point of view.

Chapters 2 through 4 offer a somewhat deeper discussion of the various types of layering. This is also where I relived unpleasant flashbacks of string-concatenated T-SQL queries, invoked right in code-behind of a web page.

I should note that Chapter 3 had a glimmer of hope with a rather brief discussion of Entity-Relationship diagrams and even—gulp—UML. Bonus points: data access code shows proper use of the using keyword.

Chapter 4 surprised me with a silly code sample along the following lines:

namespace OMS.CodeTier.BL
{
    public class Customer
    {
        public void Add()
        {
            CustomerDAL.AddCustomer (this);
        }
    }
}

Now guess what happens? CustomerDAL goes right back to Customer, thus creating a weird strongly-coupled relationship.

Again, Chapter 4 throws another surprise by listing a class which exposes public fields instead of properties—a grievous sin in the .NET land—and calls them “public variables.” There’s some nomenclature cleanup begging to happen.

namespace 5Tier.Common
{
  public System.String Address = null;
  // … other public “variables”
}

Chapter 5 is a humble, yet hopelessly outdated overview of ASP.NET MVC Preview 5. The chapter is so short that I don’t know if one can learn anything from it.

ASP.NET itself doesn’t yield well to the Model-View-Controller pattern since the View and Controller are almost inseparable by design. Hence, I suppose, an almost mandatory mention of the MVC framework.

Design Patters, Chapter 6—my favorite subject. Folks, seriously, how difficult is it to “get” the Singleton pattern? How many times has it been discussed that locking on a type is a no-no? And I was taken aback by this explanation:

“We may need to pass an instance of [the singleton in question] class to some other method, but with static classes we cannot do so.”

So the singleton is sealed and it can be passed around. Now that’s a novel idea!

The Factory pattern is accompanied by another great explanation:

“Why do we need this design pattern? Change is one thing that we cannot avoid in software development. [… more on change …] The factory design helps us make our applications “change-friendly.”

Really, that’s what Factory is about? It’s about change? Hell, “yes we can!” So you can form an opinion of your own, here’s the implementation of the said Factory:

public class ProductFactory
{
    public IProduct CreateProduct (string productType)
    {
        IProduct product = null;
        
        switch (productType)
        {
            case "BeautyProduct" : 
                 product = new BeautyProduct(); 
                 break;
            case "ElectronicProduct" : 
                 product = new ElectronicProduct; 
                 break;
            case "FoodProduct" : 
                 product = new FoodProduct (); 
                 break;
            default: break;
        }
        
        return product;
    }
}

Magic strings, um-hm, how much I dislike them.

Chapter 7: SOA and WCF. The term SOA, or Service Oriented Architecture, is bleak because it means too many things to too many people. I fully agree with Michael Nygard that it’s time to rethink what SOA actually means.

Here’s the author’s definition of SOA:

”[…] An architectural approach aimed at making it easy to introduce new features into an existing system, share data with other applications for easier integration, and bring a faster Return On Investments (ROI) to the business processes.”

Sounds like something out of the Web Economy Bulls**t Generator. That said, this chapter is too weak to be of any use. At best, it’s a two-page introduction to WCF, which does WCF no justice.

While we’re dissecting this chapter, here’s something I spotted:

CustomerCollection customers = new CustomerCollection ();
CustomerDTO[] customerArray;
// get all customers so set page length = -1 indicating full load
int pageLength = -1;

Whoa, a magic number. Are we back in the C++ land?

Chapter 8: Database Design. Always a tricky subject. The chapter has a brief discussion of data integrity, normalization and a few other essentials. But then the author goes on to create a data model in Vizio with the idea of creating a DDL script right from Vizio itself. I think this is a seriously misguided approach, but it’s your right to disagree.

Chapter 9 is about globalization and localization. I don’t understand why this chapter was included. Localization is not new to ASP.NET, and the chapter is too short to cover such a broad topic.

Proofreading and technical review

With three technical reviewers on board, I expected better quality of content. I’m not sure whether misconceptions and inaccuracies where pointed out but ignored by the author and publisher. I had this happen to me on this project.

The book could also benefit from more diligent proofreading. As to downloading source code, the provided link doesn’t work.

Conclusion

The field for discussing proper architecture of ASP.NET applications is wide open, and yet this book falls on its face. It’s too brief on technical and misguided on conceptual content. What was the point of writing it?

A special thank you to the fine folks at Packt Publishing for providing this review copy free of charge.

ASP.NET consulting with imagination and passion. Hire me!

Web Site vs Web Application Project (WAP)

Fri, 13 Mar 2009 00:00:00 GMT

In ASP.NET 1.x there was only one way to create a web app—the Web Application Project (WAP). In ASP.NET 2.0 WAP was killed, deliberately or not, and replaced with the lame Web Site “model.” WAP for Visual Studio 2005 was shipped separately later.

There are several reasons I strongly dislike Web Site projects.

Sloppy project structure

This model encourages sloppy project organization. A typical web site has no structure. You’re lucky if you see a namespace here and there. In my opinion, this is unacceptable. Since less competent developers simply use what comes out of the box, Web Site is a “bad practice” from the get-go.

Not long ago, I took over a project from someone who had everything dumped into a single Web Site. There were no logical or physical tiers. A Web Site has no solution file per se, so the guy made no effort to separate concerns.

Magic folders

According to MSDN, “You can store source code in the App_Code folder, and it will be automatically compiled at run time.” In real life, I see that App_Code is a garbage can where people throw code they don’t know where to put. Instead of thinking through which namespace a class should go to (logical organization), or even which folder (physical ogranization), App_Code serves as a dumpster.

There’s a whole bunch of other magic folders I’m not comfortable with.

Please note: this isn’t a discussion about convention vs configuration. It’s not like you can rename App_Code or stop its on-the-fly compilation. It’s imposed on you.

Migration

You don’t learn the true meaning of pain until you have to migrate a decent-size Web Site to a WAP. There’s no automatic migration. It’s all manual and very painful. I don’t want to belabor the point. Scott Guthrie and Mohamed Meligy have lengthy instructions. I had to go through a migration ordeal recently, and it wasn’t fun at all.

Beware of the following side effect: conversion to WAP resets AutoEventWireup.

The bin folder

Again, MSDN states, “You can store compiled assemblies in the Bin folder.” I inherited a project where all dependencies where simply dumped into bin. Another dumptser. In a WAP, you don’t mess with bin. You set references and they are copied into bin when the project is built.

When you migrate a Web Site to a WAP, you have to go and clean out the bin folder by hand.

Conclusion

In my no-so-humble opinion, the ASP.NET Web Site model is an aberration. I wish Microsoft retired it as a failed experiment.

ASP.NET consulting with imagination and passion. Hire me!

Cassini vs IIS

Thu, 12 Mar 2009 18:11:24 GMT

Cassini is a “simple, fully managed Web server that hosts ASP.NET” (source). It’s a lightweight “server” you get when you create a new ASP.NET application in Visual Studio.

Cassini has been pitched to those who don’t have IIS on their computers but want to develop in ASP.NET. This works great for hobbyists. However, Cassini is no IIS. It’s much slower, it hangs and crashes easily.

The reason I’m writing this is to convince you not to use Cassini within an organization. Sooner or later you will deploy your app on a real web server only to realize that something is badly broken. The problem never came up because Cassini is not a real web server and therefore issues were simply swept under the carpet.

ASP.NET consulting with imagination and passion. Hire me!

Class View Pane: An Overlooked Visual Studio Gem

Thu, 12 Mar 2009 17:55:50 GMT

For me, a quick way to see if a project is properly structured is to go to View | Class View. This is one badly overlooked but handy Visual Studio tool.

Class View gives you a general idea of whether you created a good namespace structure, whether classes have decent names, etc. This is where you catch bizarre class names like _Default.

For example, below is a screenshot of a brand new site created off the Small Business Starter Kit:

Class View reveals that the project is flat like a pancake, no logical structure in sight. The fact that it’s a web site, not a Web Application Project (WAP), somewhat explains this chaos, but that’s a different story (a post is coming, believe me).

ASP.NET consulting with imagination and passion. Hire me!

Let Your Code Fail Early

Mon, 26 Jan 2009 00:00:00 GMT

To the list of disturbing practices I nominate this:

if ([some critical resource] != null)
    [do something with this critical resource];

The critical resource above could be an essential configuration setting, a file, a control, etc. Its absense should lead to an exception so that you, the developer, can figure out this anomalous flow early, before the product ships.

For example, during a recent code review, I found a chunk of code responsible for validation. There was an explicit check for a validator, and if one wasn’t found then, well, validation didn’t happen. In this application, if a validator goes missing, it’s an abnormal situation which we should catch in development. Obfuscating it with a null check only leads to trouble.

The twin brother of evil null checks is a swallowed exception:

try
{
  // some important logic
}
catch (Exception ex)
{
}

If you’re absolutely, positively sure it’s Ok to swallow an exception like this, fine. But this happens very, very rarely.

ASP.NET consulting with imagination and passion. Hire me!

Keeping Pulse on Your Site With ASP.NET 2.0 Health Monitoring

Fri, 23 Mar 2007 00:00:00 GMT

One of the best, yet often overlooked, features of ASP.NET 2.0 is health monitoring. I believe it is absolutely essential to be notified of any problems with your web application, and this is where health monitoring comes in handy. A few years ago I wrote an article about custom error pages and demonstrated various ways to tap into error details. Health Monitoring is a natural progression of that approach.

ASP.NET consulting with imagination and passion. Hire me!

The Dark Side of File Uploads

Thu, 12 Jan 2006 00:00:00 GMT

I saw a December MSDN article, entitled Uploading Files in ASP.NET 2.0, and wanted to offer my comments on some gotchas with uploading files. I’ve spent countless hours and tried numerous hacks to tame file uploading and have enough bruses from hitting my head against the wall (figuratively speaking).

ASP.NET consulting with imagination and passion. Hire me!

Session_Start or Session_OnStart?

Sun, 18 Dec 2005 00:00:00 GMT

Ever since I started to develop with ASP.NET, I’ve been wondering why global.asa from the ASP days quietly moved over to ASP.NET as global.asax. When you look at it, it just feels so outdated, so VBScript-ish, so loosely–typed. And what is the right way to name event handlers?

ASP.NET consulting with imagination and passion. Hire me!

Crafting Lightweight Page Templates with CSS

Sun, 19 Sep 2004 00:00:00 GMT

Giving your web application a consistent look and feel is a task of paramount importance. Yet, templating in ASP.NET has been complicated, to say the least. Learn how you can craft lightweight, efficient page templates with CSS.

ASP.NET consulting with imagination and passion. Hire me!

Weather Custom Server Control

Sat, 11 Sep 2004 00:00:00 GMT

Need a quick and easy way to display weather on your site? Templated custom server controls to the rescue!

ASP.NET consulting with imagination and passion. Hire me!

Adding Variables To Style Sheets

Thu, 08 Jul 2004 00:00:00 GMT

Even though the spec defines CSS as a style sheet language, this language is missing one of the essential features: variables. Every time I've seen people in newsgroups ask how to implement variables in CSS a typical advice was to build the style sheet on the server. Luckily, it is easy to do in ASP.NET with the help of HTTP Handlers.

ASP.NET consulting with imagination and passion. Hire me!

Building Dazzling Charts With Office Web Components

Tue, 08 Jun 2004 00:00:00 GMT

Need to create eye-popping charts in real time and do it at no cost at all? Give Microsoft Office Web Components a try.

ASP.NET consulting with imagination and passion. Hire me!

Make Every Web Page Printer-Friendly

Wed, 02 Jun 2004 00:00:00 GMT

You found an article online and want to print it to nicely punch thee holes on the side and store it with other useful stuff. Almost every site nowadays provides a printer-friendly page of this and that, but some sites don't and you're still stuck with staring at their printed navigation bar, footer, ads, etc, for ever and ever. All this online decor means nothing on paper. How do you strip page parts that are irrelevant for print?

ASP.NET consulting with imagination and passion. Hire me!

Beware Of Deploying Debug Code In Production

Wed, 05 May 2004 00:00:00 GMT

You have spent several months developing a killer web application (a web site, perhaps) and the long anticipated release day has come. You deploy the application and take it for a test drive. As you navigate from page to page you notice that each page “thinks” before rendering. What’s going on? Didn’t Microsoft folks promise code compilation and ultra fast execution? Isn’t it why we beat ASP, Java and PHP by such a wide margin?

ASP.NET consulting with imagination and passion. Hire me!

Bringing CSS2 to Visual Studio.NET

Tue, 27 Apr 2004 00:00:00 GMT

Even though the CSS2 Specification has been around since 1998 its support in the Visual Studio line of products has been rather weak. In this article you’ll learn how to enhance IntelliSense in Visual Studio.NET to display CSS2 properties.

ASP.NET consulting with imagination and passion. Hire me!

Remastering Web Form Templates

Sun, 18 Apr 2004 00:00:00 GMT

Visual Studio.NET comes with a number of templates for all kinds of coding occasions. The one I'm going to talk about in this article is the one you probably use most often (provided you are an ASP.NET developer): the Web Form template. Default templates suffer from being stuffed with needless markup. In this article we'll analyze what is supposed to be there and learn how to clean them up.

ASP.NET consulting with imagination and passion. Hire me!

What's In Your DOCTYPE?

Tue, 13 Apr 2004 00:00:00 GMT

When you create a web form in Visual Studio.NET using the canned "Web Form" template you might ask yourself, "What is this DOCTYPE declaration about?"

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >

What is this strange-looking beast?

ASP.NET consulting with imagination and passion. Hire me!

ASP.NET State Management: View State

Sun, 14 Mar 2004 00:00:00 GMT

ASP.NET view state is a great feature and an essential tool for web development of today. It maintains the state of a page as it travels back and forth. There is no more need to worry about restoring values of page controls between postbacks. In this article you will get an in-depth perspective on view state. We will talk about ways of reducing unnecessary payload and protecting view state from prying eyes.

ASP.NET consulting with imagination and passion. Hire me!

Skinning Web Applications with CSS

Sun, 22 Feb 2004 00:00:00 GMT

The common approach to skinning web applications lies in reshuffling controls on a page. Traditionally developers define templates with different color schemes and/or control positioning, tables and inline font tags. While this used to be a perfectly viable solution the overhead of run-time application of these skins is staggering. A much better way is to separate skin structure from presentation and let CSS take care of the layout and typography.

ASP.NET consulting with imagination and passion. Hire me!

Producing XHTML-Compliant Pages With Response Filters

Fri, 13 Feb 2004 00:00:00 GMT

Programming with web standards in mind, although vastly ignored, is becoming more and more important. It almost seems it took too long to promote ASP.NET. Now that we're over the hill and "this stuff works" it is about time to start paying attention to web standards. In this article you will learn how to implement a response filter and plug it into the ASP.NET pipeline. The filter will transform outgoing HTML into XHTML 1.0-compliant markup.

ASP.NET consulting with imagination and passion. Hire me!

ASP.NET Custom Error Pages

Sun, 01 Feb 2004 00:00:00 GMT

ASP.NET provides a simple yet powerful way to deal with errors that occur in your web applications. We will look at several ways to trap errors and display friendly meaningful messages to users. We will then take the discussion a step further and learn how to be instantly notified about problems so you can cope with them right away. As a geek touch we will also track the path 404's travel.

ASP.NET consulting with imagination and passion. Hire me!