Comet with node.js and V8

http://amix.dk/blog/post/19484

A presentation (slideshow, no audio or video) on node.js, a JavaScript web-server running on Google’s V8 engine. Very interesting concept – using an event-based system vastly simplifies the code needed to server data. There’s plenty of discussion about node.js on the interwebs at the moment – hopefully it will grow and become more than just a curiosity.

Gallery of Processor Cache Effects

http://igoro.com/archive/gallery-of-processor-cache-effects/

Interesting blog post about the effects that processor caches may have on performance. Examples are in C#, but really apply to any language.

Microsoft’s Creative Destruction

http://www.nytimes.com/2010/02/04/opinion/04brass.html?pagewanted=1&ref=opinion

Opinion piece from the NYTimes regarding Microsoft’s recent lack of innovation (at least, in the area of shiny gadgets). Written by an ex-vice-president of Microsoft.

How Many Passes?

http://blogs.msdn.com/ericlippert/archive/2010/02/04/how-many-passes.aspx

Summary article from Eric Lippert describing the differences between the C# compiler and a “traditional” compiler, and listing the various passes made over the symbol tree.

A Deadlock Holiday

http://www.theregister.co.uk/2009/12/10/verity_stob/

Very funny tongue-in-cheek article about the current state of parallel / multicore coding techniques, from Verity Stob of The Register.

A Maturity Model for Source Control

http://lucas-ward.blogspot.com/2010/02/maturity-model-for-source-control-scmm.html

Semi-opinion piece assigning levels to types of source-control systems – from “No SCM” through “Clunky” to “Speedy, Invisible, and Highly Capable”.

Luckily, that is now changing with the recent release of .less (Dot Less). This is a port of the Ruby LESS library to .NET. It’s still in beta, so be warned that the API is still in a certain amount of flux. (That’s a good thing however – I’d rather have a bit of pain in the beta stage, in return for a well-thought-out API later on). The authors are very responsive – there’s a friendly discussion group – and the couple of bugs I’ve reported have been fixed within a very short time frame. This project seems to be in very active development, and I’m extremely impressed with it. It’s so simple to use, and gives CSS development a much-needed shot in the arm, that using this library seems a no-brainer decision to me.

So what benefits does this library give you? (Examples are taken from the .less homepage).

1. Minification

The final output from .less is a compacted (or minified) version. This means you can write your CSS with as many comments and whitespace as you like, without worrying that the client-side download will be huge. This might seem like a “meh” feature, but it’s free and will have immediate beneficial effects on your bandwidth.

2. Variables

CSS doesn’t support any form of variables or macros, so constants (the worst culprit being colours) get copied around the CSS file. That’s fine until you decide that the pink-on-orange colour scheme isn’t working, and you need to make a change. .less allows you to define variables using the syntax “@name: value”, and then reference them anywhere a value would otherwise be used.

Example:

@brand_color: #4D926F;

#header {
  color: @brand_color;
}

h2 {
  color: @brand_color;
}

3. Mixins

We’re now in a second round of “browser wars”, with modern browsers providing useful features such as border-radius via non-standard extensions. We also have to cope with Internet Explorer still making use of odd syntax for features such as opacity (via filter). The upshot of this is that to define certain CSS effects, we have to provide three or four CSS style properties, to cover various browsers. Mixins allow this bloat to be ameliorated by defining a class with the desired properties, and then “mixing” them into another class.

Example:

.rounded_corners {
  -moz-border-radius: 8px;
  -webkit-border-radius: 8px;
  border-radius: 8px;
}

#header {
  .rounded_corners;
}

#footer {
  .rounded_corners;
}

4. Nested Rules

This feature is probably of least interest to me, since I favour single-line rule formatting, however if you write multi-line rules, then this could be a very useful feature. Nested rules allow “inheritance” of CSS rules, such that more specific rules may be nested within a less-specific parent rule.

Example:

#header {
  color: red;
  a {
       font-weight: bold;
       text-decoration: none;
    }
}

I could possibly see myself using it for :hover rules and the like.

5. Operations

Since I’m merging .less into an existing codebase, I haven’t yet refactored my CSS to make use of this feature. Operations allow arithmetic to be performed on expressions involving variables. For example, instead of defining variables for a colour and its lighter equivalent, you can instead just define a variable for the colour, and then computer the lighter colour.

Example:

@the-border: 1px;
@base-color: #111;

#header {
  color: @base-color * 3;
  border-left: @the-border;
  border-right: @the-border * 2;
}

#footer {
  color: (@base-color + #111) * 1.5;
}

Alternative Usage

The homepage gives instructions for a quick-up-and-running scenario, however I already had code to handle caching and combining of stylesheets, so I wanted to hook into that. It’s easily possible to process CSS as strings if desired:

// .less format CSS as string in 'input'.
var dotLessEngine = new dotless.Core.engine.ExtensibleEngineImpl( input );

// Transformed CSS now in 'css'.
var css = dotLessEngine.Css;

// Now minify...
var dotlessMinifier = new dotless.Core.minifier.Processor( css );

// Output CSS suitable for sending to client in 'output'.
var output = new string( dotlessMinifier.Output );

Smart, and Gets Things Done

Joel Spolsky’s 2006 article “The Guerrilla Guide to Interviewing” is a real classic that’s since been made into a book. He argues that there are two things to look for when interviewing, and that a candidate needs to have both attributes – having just one is as bad as having neither.

“Everybody gives lip service to the idea that people are the most important part of a software project, but nobody is quite sure what you can do about it. The very first thing you have to do right if you want to have good programmers is to hire the right programmers, and that means you have to be able to figure out who the right programmers are, and this is usually done in the interview process.”

Read Joel’s Article: The Guerrilla Guide to Interviewing (version 3.0)

Done, and Gets Things Smart

Steve Yegge’s 2008 response article reminds us that recognising smarts (in ourselves and others) isn’t even necessarily possible. He suggests that the best approach to hiring is finding “seed” employees (although obviously being able to identify them is a Catch-22 situation). To find them you either need to be lucky, or perhaps home in on them via word of mouth.

“How do you hire someone who’s smarter than you? How do you tell if someone’s smarter than you? This is a problem I’ve thought about, over nearly twenty years of interviewing, and it appears that the answer is: you can’t. You just have to get lucky.”

Read Steve’s Article: Done, and Gets Things Smart

Let’s suppose we want to represent an arithmetic operation on two numbers – such as plus, minus, multiply, etc. We could represent that operation as an enum (although to be clear – I don’t think you should):

enum ArithmeticOperation
{
  Add,
  Subtract,
  Multiply,
  Divide
}

We could then define a function to apply this operation to two numbers (highlighting will be explained later):

int ApplyOperation(ArithmeticOperation op, int x, int y)
{
  switch(op)
  {
    case ArithmeticOperation.Add: return x + y;
    case ArithmeticOperation.Subtract: return x - y;
    case ArithmeticOperation.Multiply: return x * y;
    case ArithmeticOperation.Divide: return x / y;
    default: throw new InvalidOperationException();
  }
}

That’s… sort of fine – but what happens when we want to extend it?

Adding Operators: No Compile-Time Checking

Let’s consider what happens if we want to add another operator – say exponentiation. If we add the enum value but forget to implement the switch case value, everything compiles fine. It’s only once we come to run the code, and actually hit that code path, that we discover the mistake, giving a run-time exception.

Adding Methods: Bad Code Organisation

Next, imagine what happens if we need to add more methods that switch on this enum. We might need a method returning the operator symbol, and another returning the operator precedence.

string GetOperatorSymbol(ArithmeticOperation op)
{
  switch(op)
  {
    case ArithmeticOperation.Add: return "+";
    case ArithmeticOperation.Subtract: return "-";
    case ArithmeticOperation.Multiply: return "*";
    case ArithmeticOperation.Divide: return "/";
    default: throw new InvalidOperationException();
  }
}

int GetOperatorPrecedence(ArithmeticOperation op)
{
  switch(op)
  {
    case ArithmeticOperation.Add: return 10;
    case ArithmeticOperation.Subtract: return 10;
    case ArithmeticOperation.Multiply: return 20;
    case ArithmeticOperation.Divide: return 20;
    default: throw new InvalidOperationException();
  }
}

I’ve highighted the relevant code for the “add” operator. Notice how it’s spread all over the place. Switch statements might group by operation, but they split by concept – and that’s the exact opposite of what’s usually intended with OO coding.

A Better Way

I’d suggest a better way of approaching this problem is to use an abstract class.

abstract class ArithmeticOperation
{
  abstract int ApplyOperation(int x, int y);
  abstract string GetSymbol();
  abstract int GetPrecendence();
}

class AddArithmeticOperation : ArithmeticOperation
{
  override int ApplyOperation(int x, int y)
  {
    return x + y;
  }

  override string GetSymbol()
  {
    return "+";
  }

  override int GetPrecedence()
  {
    return 10;
  }
}

// ...and so forth for the other operators.

That way, all the code for each operator sits in the same place, and adding any new methods for an operator requires all operators to be implemented before the code will even compile.

When to Use Enums

So if enums should be avoided, why do most languages include them? Personally I’d be happy without them,  but I can think of one possible reason you might want to use an enum. If you’re defining a public interface designed for consumption by other coders, you could argue that simplifying the interface at the expense of the code inside is a valid trade-off.

(Note that due to my background this is going to be Windows-centric. Please don’t take this to mean that I think Windows PCs are unfriendly – it’s just I don’t know enough about other systems to be able to comment. I also don’t want to come across as elitist – if non-IT people don’t understand something, that’s not because they’re dumb – it’s because we haven’t made computer systems obvious enough.)

1. When to Click and When to Double-Click

This one is a continual source of annoyance to IT people, and especially to those in support. It seems obvious to us which should be used when, but before you get mad with the user you’re helping, consider this: can you make rules for when to click and when to double-click? Why do you double-click an icon to perform the action, but only single-click a button? What if Windows is set to “single click to open an item”?

Add into the mix the close cousin right-clicking, together with triple-clicks in text editors, double-single-clicks to rename, and of course modified clicks (holding down control or shift), and I think confusion is the correct response.

2. Hierarchical Folders

Hierarchical folders are a great idea – don’t get me wrong – but they’re a good example of a neat metaphor overextended and hence confused. Most people are familiar with cardboard folders that can store bits of paper – and equally most people are happy to store their files in folders on their PC. Where it all goes wrong is with folders within folders, as this very rarely happens in the real world. Many users are simply unaware that they can create additional folders inside “My Documents” – hence the usual tendency to find hundreds or even thousands of files, all at the same folder level.

Making the problem even worse is the fact that “Save As” and “Open” dialogs often look nothing like the standard file explorer. This makes it more difficult to mentally link the save operation with the save location. This leads to the common problem of a user “losing” all their files – when in fact the “open” dialog has for some reason defaulted to another directory, and hence shows a different list of files to those the user was expecting.

(And don’t even get me started on the fact that folders like “My Documents” appear in TWO locations in the folder tree – the physical one that users can’t find or recognise, and the virtual one which isn’t supported by all applications).

3. Using Add/Remove Programs

I need to clarify here. When a user wants to remove a program they chose to install, they head over to Add/Remove Programs – no problems. I’ve found however that when it’s software they didn’t install (or didn’t intentionally install) – there’s a problem. Messages that pop-up on start-up, unwanted system tray announcements, even auto-starting applications – these are all a source of annoyance, and often there’s no obvious way to associate the offender with the appropriate entry in Add/Remove Programs. Often trialware pops up nag screens at startup, giving the user the option to purchase it – but without an option to uninstall.

Even worse is the case where a user wants to keep the application, just not have it launch at startup. There are many different ways an application can hook into the startup sequence, and most of them are inaccessible unless you’re comfortable using something like msconfig (which, let’s face it, non-IT people aren’t).

4. Installing Bundled Software Hurts

IT people know that bundled software (aka “crapware”) isn’t included for our benefit – it’s generally a way hardware manufactures or system builders lower costs by basically pushing unwanted adverts for unwanted products onto your machine, in the hope that you won’t be able to uninstall them, and will finally buy them (see item #3 above).

Unfortunately a standard user assumes that if a hardware item comes with a disk, that disk is there for a good reason – and so installs the lot. Sometimes this is just an annoyance, but sometimes it’s more sinister – bundled software often stops the PC functioning correctly. The worst offenders seem to be the software that comes with wireless network adapters. For some reason they all want to turn off Window’s standard wireless zero-configuration system, and install their own. Sadly, their own offerings often don’t work (especially if they were written pre-XP) and the user is left with a completely non-functioning wireless system. Had the user simply plugged in the hardware and let Windows do the rest, it probably would have worked. The instructions said to install the software – and possibly stung by all the geeks who kept telling them to “RTFM” – they did so.

5. That There Is A Choice Of Software

Odds are that you’re reading this on Firefox – or if not, as a reader of a coding blog, you at least know the name of the browser you’re using. This almost certainly isn’t the case for the majority of PC users – they don’t use a browser, they use the internet (or if not the internet, then they use msn, facebook, google, or whatever). Most people simply use the browser as a means to an end. The same goes for music players, email clients (generally dictated by their ISP), and anti-virus (generally the one with the biggest display in the local PC shop).

Unfortunately this means that when things go wrong, or go expensive, or go ad-ridden, these users aren’t even aware they can change. Adverts on the web are annoying, but if you have no idea you can change your browser and install an ad-blocker, you have no choice but to suffer them. This also means that poor software can survive in the marketplace – since for correctly positioned, pushed, and marketed software, there ceases to even be a marketplace.

6. What Updates Do

While writing this article – the first two weeks of September – my laptop has installed updates on the 1st, 4th, 9th, 11th and 14th of the month. Since this is a rather slow laptop, that means that if I choose to install them, I have to put up with bad performance, and if I don’t, I have to put up with repeated nagging. Even when I do install them, I know that in another couple of days they’ll be back.

I know updates are necessary – but do we need them every three days? Do they need to be quite so slow? And do they have to nag when I’m trying to use my PC – couldn’t they wait a while to see if the screensaver kicks in, as that’s likely to be a better time than now, now, now.

7. Software Licensing

We need to put aside a discussion of whether software should be free or not for this one, and let’s just assume that people are happy paying for software for now.

The problem is that buying software isn’t really like buying other goods – what you buy isn’t the box, or the media, but a license. With normal goods, once you’ve purchased it, you keep hold it, and if it turns out to be an illegal purchase, someone (eg the police) have to come and physically remove it. With software, if the vendor decides it’s not a valid purchase, then the software magically stops working, with no easy recourse for the customer.

I’ve come across many cases of people who thought they were legitimately purchasing software, but in fact weren’t – either purchasing from someone who was knowingly selling illegal software, or purchasing from someone who believed they had the right to sell, but didn’t. Either way, the honest software purchasers had no immediate way of knowing the software they were buying wasn’t legit.

To be fair, most software vendors are taking steps to improve this – although the cynic in me says this is mainly to protect revenue streams, not customers.

8. What Memory (RAM) Is For

I think most computer users have a pretty good idea what disk storage is for – that’s where their files are stored. What I think users have a bigger problem with is volatile memory. It’s very difficult to describe to a non-techie what RAM actually does – just saying “it’s what running programs use” doesn’t give a full description by any means.

Making the problem worse is that fact that most consumer PCs are sold with the bare minimum of RAM. Users can easily see that they have a good amount of disk storage free, but it’s more difficult to get a feeling for whether they have enough RAM. Most users simply don’t realise that computers don’t have to be slow, and don’t have to spend all their time swapping virtual memory.

9. How To Use Networking

As computers become cheaper, many households now have more than one. As that happens, this question is asked of me more and more often: “I’ve saved my files on the office computer; how can I get them on the laptop?”. The first couple of times, I set up a simple home network and created shortcuts to shared folders on each desktop. Unfortunately, this didn’t really cut it.

I think the main problem is that home networking fundamentally doesn’t fit in with most people’s work patterns – if they’re working on the laptop (say), why would the office computer be switched on? Having to leave both computers on just doesn’t fit. From the user’s point of view, sometimes the files are there (when the other computer is on), and sometimes they’re not.

I’ve found that solutions like Dropbox are much more palatable – while all the home computers might not be switched on, the internet connection almost always is. The networking in this case is transparent – the user doesn’t have to do a thing – and the files are magically up-to-date on all their computers.

10. The Display Is Not The Computer

For a long time, the sheer size of CRT monitors led many users to assume the monitor was the computer, and if they thought about the box below the desk at all, they thought it was “the hard-drive”. Now that monitors are much slimmer, people understand that the monitor is just a display mechanism, and the computer actually is under the desk.

Where it all goes a little confusing is when the computer in question isn’t near the display in front of the user – remote desktop, remote assistance, and the like. Even more flummoxing seems to be the notion of servers in general – for some reason a computer without a display unit doesn’t seem to be easily understandable. Despite the familiarity of the web, the idea that accessing a website involves a computer, often running a familar operating system, somewhere remote, seems a difficult one.

Any More?

Have I missed any other concepts that are repeatedly misunderstood? Any common problems you have to deal with? Let me know!

I’m sure most web developers know about image rollovers (using separate images for normal and “hover” states of anchors). Hopefully also the use of “CSS Sprites” is becoming better known – combining the normal and rollover images into a single physical image file to speed up load times and reduce flicker. I won’t cover those techniques here.

However, if you want the anchor or button to size to its contents, it’s more difficult to make use of these techniques. Here’s one way.

(The final result – view demo).

Start With Markup

Before diving into fancy techniques, get the markup down as you would like it, if you didn’t have to style anything.

<a href="..." class="rollover">Button Text</a>

Ideally we want the markup to be clean and not compromised by styling requirements.

Handle Degradation Gracefully

My technique is going to make use of JavaScript, so let’s handle the case where the user has it disabled for some reason. Here’s some very basic CSS to give the button a simple style:

a.rollover
{
  background-color: #00f;
  border: solid 1px #000;
  color: #fff;
  font-weight: bold;
  padding: 4px;
  text-decoration: none;
}

a.rollover:hover
{
  background-color: #008;
}

Add Styling Naively

Next, I’m going to add some rollover styling – but in a way that isn’t complete. Firstly I created a simple rollover image, but made it very wide – it needs to be at least as wide as the widest button is ever going to be:

I’m going to define my rollover styling against a class selector of “extra” – you’ll see where that comes from in a moment.

a.rollover.extra
{
  background: url(buttons.png) repeat-x left 0;
  border: none;
  height: 27px;
  padding: 23px 40px 10px 40px;
  position: relative;
}

a.rollover.extra:hover
{
  background-position: left -57px;
}

Note that we’ve had to undo some of the styles applied previously, such as border.

We’re kind of getting there, but our buttons won’t look correct on the right-hand-side.

Use JavaScript To Add Styling Markup

To fix the right-hand end-caps, we need to modify our markup. However, I really don’t want to have to do that on my pages – afterall, I might change my mind about the site styling.

Here I recommend using JavaScript to tweak at runtime the markup to what we need. I’m going to use jQuery for this:

$(function() {
  $('.rollover')
    .addClass('extra')
    .append('<div class="cap"></div>');
});

Basically, when the pad is ready, I find all elements with class “rollover”, add another class (“extra”), and append into the rollover button an empty span element which has a class of “cap”.

That class “extra” triggers the image rollovers. The “cap” span can be styled as follows:

a.rollover.extra .cap
{
  background: url(buttons.png) no-repeat right 0;
  height: 100%;
  position: absolute;
  right: 0;
  top: 0;
  width: 40px;
}

a.rollover.extra:hover .cap
{
  background-position: right -57px;
}

And voila!

If you’d like to see this technique in action, please view the demo.

Unfortunately, it seems that installing Internet Explorer 8 (IE8) sometimes has some adverse affects on other applications. Here’s how to fix this.

The problems we’ve experienced following installation of IE8 have been:

• Windows Explorer opens folders in new windows, even if you have “Open each window in the same folder” checked;
• “Open in new tab” doesn’t work in IE8;
• Can’t connect to databases using SQL Management Studio Express 2008 (”Unable to cast COM object of type ‘System.__ComObject’ to interface type ‘Microsoft.VisualStudio.OLE.Interop.IServiceProvider’. Exception from HRESULT: 0×80004002 (E_NOINTERFACE)”).

The solution is pretty simple:

1. Go to Start -> All Programs -> Accessories, right-click “Command Prompt”, and choose “Run as Administrator”.
2. OK the user access warning dialogs.
3. Enter “regsvr32 actxprxy.dll”.
4. Reboot.

Simples! No more tearing my hair out.

(I’m going to use C# in my examples here: some of these points might not apply to all languages. By default, an assertion will not fire in a C# release build, and furthermore, the code inside will not even be executed).

Update 2009-06-11: I probably haven’t been clear enough, but luckily various commenters have picked up on this: I’m not advocating removing assertions and replacing them with nothing! In general, I think assertions should be replaced with a stronger check that also runs (or can run) in a release build.

1. Pointless Guard Checking

Unfortunately in my coding travels I see quite a bit of code like this:

void Foo(Bar bar)
{
  Debug.Assert(bar != null);

  bar.DoSomething();
}

What’s the point? If bar is null, then using it will throw an exception anyway. Why add unnecessary lines of code that make reading harder?

2. Bad Argument Checking

But, you’re thinking, what if the usage is separated from the assignment?

class Foo
{
  public Foo(Bar bar)
  {
    Debug.Assert(bar != null);

    _bar = bar;
  }

  public void Method()
  {
    _bar.DoSomething();
  }

  private Bar _bar;
}

True, you want to catch the error as it happens, not later on in the method. But shouldn’t you be throwing an ArgumentNullException instead?

3. Difficult Detective Work

So now you’re telling me that you’re not writing component code, and the only client of this class will be the application it’s embedded in. Why not save some effort and skimp on the checking code, and make it debug-only?

Fine idea… until you get a crash report from one of your users, and the stacktrace points to a NullReferenceException in Method(). Now you have to figure out where the null value got passed to the constructor… a potentially much more difficult task.

4. Differences Between Debug and Release

If you’re like me, you generally run the applications in debug. Your customers however, run in release. Why make the differences between these two versions any bigger? Even if you don’t intend your debug statements to change program state, it’s all too easy to accidentally do so:

• Running lazy-initializers or singleton constructors;
• Loading data from the database via an ORM;
• Moving data in or out of a cache;
• Running static constructors.

5. Too-Shy Sanity-Checking

Sometimes, despite the above warning, you really do have sanity-checking code that you’d like to run in a development or test environment to catch regressions, but which is too slow to give to general users. (I read somewhere that Excel has two computation engines: a simple, slow, reference one, and a fast, parallel, release one. Testers can run the two in parallel, and any differences are automatically flagged as errors).

So you might be tempted to do something like:

Debug.Assert( SlowlyAndCarefullyVerifyInternalState() );

The problem I have with this is that the debug/release division is way too blunt.

• Suppose a tester wants to test a release build, but also perform the sanity-checking?
• Suppose a customer finds a bug in a complex calculation, and you want them to run the checks?
• Suppose a developer wants to debug performance issues in the non-checked code?

I would suggest you move the conditionals for code like this to a (possibly hidden) configuration setting. Someone wants to run in slow-and-safe mode? No problem, just tell them the registry setting (or whatever). By all means, change the splash screen or title bar or whatever so it says “test mode”.

The advantages of this method are:

• Anyone can turn it on and off;
• Sanity-checking can be controlled at a much finer granularity than all-on / all-off.

6. Is It Recoverable, Or Not?

The final argument against debug assertions concerns just exactly what an assertion means.

To my mind, an assertion is different to a simple flow-control test (“did the user enter a valid number?”), which is something the program can (should) handle. By definition, an assertion is checking for a disallowed state. An assertion doesn’t check for incorrect data; it checks for an incorrect program. Continuing after an assertion leads to undefined behaviour.

So how can you continue? More to the point, why should a user even be allowed to continue? If the state really is unrecoverable, then fail. Fail fast, log the error, and bail (possibly trying to allow the user to save work, or whatever). Having a release-build application continue after what would have been an assertion is just plain wrong.

“I think there’s a world market for about 5 computers.”

- Thomas J. Watson, Chairman of the Board, IBM, circa 1948

“It would appear that we have reached the limits of what it is possible to achieve with computer technology, although one should be careful with such statements, as they tend to sound pretty silly in 5 years.”

- John Von Neumann, circa 1949

“But what is it good for?”

- Engineer at the Advanced Computing Systems Division of IBM, commenting on the microchip, 1968

“There is no reason for any individual to have a computer in his home.”

- Ken Olson, President, Digital Equipment Corporation, 1977

Wise words indeed.

You need to learn when you know you don’t know enough, sure. It’s easy to pick up a book when you’re feeling clueless. The more dangerous time is when you think you do know enough. Coding (and computer science) is like the Red Queen’s Race: you need to run as fast as you can just to stay still.

• When was the last time you bought or borrowed a technical book?
• When was the last time you bought or borrowed a technical book, and then actually read it?
• When was the last time you bought or borrowed a technical book, and read it, where it was of no immediate use to your job?

Leave your comfort zone. Admit your ignorance. Learn something new. Learn something useless. Because next year, you might be kicking yourself for calling it useless. Don’t tell me that what you know now is all you’ll ever need to know. Don’t get quoted in next year’s list.

If you liked the quotes above, you might also be interested in “A Double Handful of Programming Quotes“.

One common example (that we make use of heavily in EasyAs123Web.com) is using a handler to serve and generate images on-the-fly. Our user images are stored in the database, and are immutable – they never change. Hence we’d like the client browser to cache the image returned.

Example Handler

Let’s start with the shell of a generic handler, MyHandler.ashx.cs:

public class MyHandler : IHttpHandler
{
  public void ProcessRequest( HttpContext context )
  {
    ...
  }

  public bool IsReusable
  {
    get
    {
      return true;
    }
  }
}

Further code will go where I’ve marked with ellipses.

Reponse Headers

For some reason, ASP.NET automatically adds headers that stop the browser from caching the content, and you can’t just override them. Instead, you’ll need to clear them all out first:

context.Response.ClearHeaders();

Next we want to mark the content as fully cacheable, and expiring at some date in the future:

context.Response.Cache.SetValidUntilExpires( true );
context.Response.Cache.SetCacheability( HttpCacheability.Public );
context.Response.Cache.SetExpires( DateTime.Now.AddMonths( 1 ) );
context.Response.Cache.SetLastModified( DateTime.Now.AddMonths( -1 ) );

(I’ve marked the content as expiring in a month, but you could easily add a year or ten years or whatever).

If you are able to calculate some form of hash for your content (which you should be able to do pretty easily), you can add an ETag:

Guid hash = ...;

context.Response.Cache.SetETag( "\"" + hash.ToString().Replace( "-", "" ) + "\"" );

Finally, there’s one more trick which is incredibly useful for allowing browsers to avoid re-downloading the content.

Browsers may include the “If-Modified-Since” request header. If you ignore this header, no problems occur: you just send the content as usual. However, you can use it to inform the browser that your content hasn’t changed since the last time it was requested.

If your content really hasn’t changed, instead of sending a “200 OK” response with all the content, you can send back a “304 Not Modified” without any content whatsoever:

var textIfModifiedSince = context.Request.Headers["If-Modified-Since"];

if( !string.IsNullOrEmpty( textIfModifiedSince ) )
{
  context.Response.Status = "304 Not Modified";
  context.Response.End();

  return;
}

So instead of sending back a potentially large piece of content, you can send back just the tiny response headers.

You can do a similar trick with “If-None-Match” – I’ll leave that as an exercise.

Debugging

Making these changes is all very well, but can you be sure that your changes are actually having the desired effects?

There are two great tools you can use to actually view the requests sent by the browser, and the response sent from your web-app:

• For debugging with Firefox: Live HTTP Headers.
• For Internet Explorer: Fiddler 2.

If you care about the speed and bandwidth usage of your ASP.NET application, I’d say that these two are pretty much indispensable. You’ll want to test with both: different browsers make subtly different requests, and interpret the responses differently.

You might also want to use YSlow for Firebug: this has some nice graphical displays of page assets.

Example – Content Not In Cache

Request and response, some lines omitted for clarity.

GET /!!/_Serving/StaticFile/Style/Pro/Images/HomeCreate.jpg HTTP/1.1
Host: www.easyas123web.com

HTTP/1.x 200 OK
Cache-Control: public
Content-Type: image/jpeg
Expires: Mon, 01 Jun 2009 08:58:36 GMT
Last-Modified: Wed, 01 Apr 2009 08:58:36 GMT
Etag: "45403f772717d1c63c0b8774e4a124b7"
Content-Length: 20696
... 20K of content here ...

Example – Content In Cache

Request and response, some lines omitted for clarity.

GET /!!/_Serving/StaticFile/Style/Pro/Images/HomeCreate.jpg HTTP/1.1
Host: www.easyas123web.com
If-Modified-Since: Wed, 01 Apr 2009 08:58:36 GMT

HTTP/1.x 304 Not Modified
Cache-Control: public
Expires: Mon, 01 Jun 2009 09:03:51 GMT
Last-Modified: Wed, 01 Apr 2009 09:03:51 GMT
Etag: "45403f772717d1c63c0b8774e4a124b7"