Looking through some of the submissions on the site, I was struck by how… well… random most of them are. Without meaning to be rude, they just look like someone went through the list, randomly assigning colors. Many many programmers believe coding and graphic design are polar opposites – that if you’re a coder, you must necessarily suffer from “programmer art”, and hence that it’s pointless to ever try to learn better design skills. I completely disagree with this diagnosis.

I’m going to use only one design rule for this color scheme – consistency: keep similar things similar, and make different things different.

Basics

I’ve already decided to create a “dark” theme, so the background will be black. I also want to highlight important or dangerous elements of the source, and downplay incidental aspects. This idea will modify each of the colors chosen, and help suggest colors where there is no clear choice. Each choice will be reflected as far as is possible across many file types – for example, a C# comment should probably be the same color as an XML one, a JavaScript one, etc.

I’m also going to make use of color shades. I know Visual Studio has to cater for people using low-color displays, remote desktop, and those with reduced vision, but its use of primary colors leaves it looking a little dated. Color shades can be used to bring the look a little more up-to-date, and to group related elements, while still being able to distinguish between them.

Comments – Green

Comments have always been green in Visual Studio, and I’m going to keep them that way – a vibrant green, made bold, to catch the eye. (If comments aren’t important, then why are you writing them?) Comment hyperlinks and the text in #region blocks also match.

Literals – Blue

String literals are red in the standard Visual Studio color scheme, but I wanted to reserve that color for errors and the like. In my mind strings are blue (don’t ask me why) so I’ve chosen a light blue for strings.

With consistency in mind, what else should match this?

• String literals are blue, so why not other literals, such as integers? The common color will highlight “magic values” in code.
• We’ll need to colorize XML and HTML, so we can make attribute values blue too.
• JavaScript and SQL obviously have literals.
• I’ve also chosen to see CSS values as literals – they go blue too. (You could easily argue the toss about that though).

Keywords – Gray

Since the background is black, ‘unadorned’ text will be white – a nice easy choice. How about keywords?

I want to make them a different color – so I can tell when I’ve typed ‘retrun’ for the billionth time – but I don’t consider them to be “core” code. I think of them as scaffolding around my identifiers. (Perhaps I’m a LISPer at heart). I’ve chosen to keep them a neutral color, but a dimmer shade, so they fade out – hence gray.

Types – Yellow/Orange

Colorizing types is handy as it again allows me to see when I’ve mis-typed something. I want them to stand out (so a dim color is out), and I don’t want them confused with anything else – so reds, greens, and blues are gone. Yellows and light oranges seem a good choice – close enough to the normal white text, but sufficiently different to catch the eye. I’ve chosen a light orange for types, and highlighted interface types as yellow. (I figure that looking at how interfaces are defined and used is often a good way to understand the structure of a body of code – hence the slightly more eye-catching color).

(Oddly enough, this doesn’t seem to work for types in C++ – they always seem to come out white. Not sure why.)

Errors, Warnings, and Oddities – Red

This was an easy color to choose – red (for me) means stop and think. There are a few code constructs that I wanted to highlight as either dangerous or needing attention:

• Compiler errors and warnings;
• Preprocessor directives;
• Breakpoints.

Editor Overlays – Purple/Dark Blue

Visual Studio now highlights parts of the source depending on where youyr cursor is – it highlights matching braces, and will also display all usages of the symbol at the caret. These display can change rapidly, so shouldn’t be too distracting. I’ve chosen a dark purple, which is subtly visible, but which blends in with the black background.

We need a related color for the selection too, so I’ve chosen dark blue.

Omissions

There’s still quite a few entries in the colors list I haven’t filled out – the main areas being:

• VB.NET;
• XSLT
• IntelliTrace
• Test Coverage

If you fancy addressing these omissions and sending me back an updated settings file, I’ll be happy to credit you.

Conclusion & Download

So there you go. Obviously color schemes are very personal (and contentious). I think I’ve done a pretty good job; you might well think otherwise. Even if you don’t like this particular scheme, I hope you’ll agree that setting a few design principles in place before assigning colors can help you choose (and use) the colors effectively.

Sadly there’s no way to upload my settings to StudioStyles, and I’m too lazy to re-do all the work by hand. Until they allow that option, I’ll host the settings from here:

Download hackification.vssettings

Save this file somewhere, then use Tools -> Import and Export Settings… to merge them in.

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 serve 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”.

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 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“.

Courier New has been around since 1955 – and that it’s been around so long is a testament to its readability. However since then, display technology has radically changed – I’d be amazed if you weren’t reading this article on some form of TFT panel, and if using Windows, with ClearType enabled.

Enter Consolas.  For the release of Office 2007, Microsoft commissioned a set of modern fonts, designed to be highly readable on screens that use ClearType: Calibri, Candara, Cambria, Consolas, Constantia and Corbel. Of that set, Consolas makes an excellent monospaced code font.

Here’s Courier New:

And here’s Consolas:

To my eyes, that’s a big improvement. You’ll notice as well that Consolas is slightly narrower, enabling you to fit a bit more text on the screen.

So where can you get it?

If you have Visual Studio, you can download it directly from Microsoft:

http://www.microsoft.com/downloads/details.aspx?familyid=22e69ae4-7e40-4807-8a86-b3d36fab68d3&displaylang=en

Or if not, it comes as part of the free Powerpoint viewer:

http://www.microsoft.com/downloads/details.aspx?familyid=048DC840-14E1-467D-8DCA-19D2A8FD7485&displaylang=en

This article is really just thinking aloud – I’m interested to see what people think, and since my brainwaves always have fatal flaws that I don’t see in advance, interested to see who can point them out. (Incidentally, if you’re familiar with the reasons why IE6 still has market share, you can skip the first half of this article.)

First, a bit of background

So… you’ve just released your latest web app, and you want to support those 25% (or whatever) of users who still use IE6, but you don’t want to spend an inordinate amount of dev time supporting what is a shrinking market.

There have been various suggestions that we should just display some sort of banner pointing the user to browser upgrades or alternatives, but is that always feasible? To my mind there are two main reasons people don’t upgrade from IE6:

1. They don’t have administrative rights to do so (for example in a corporate setting);
2. They don’t look at or click any upgrade notices, or indeed understand what a browser is.

People in group #1 cannot upgrade or change browser (except Chrome – more later), so suggesting they upgrade is pointless. The people in group #2 simply don’t realise that a browser is a choice, don’t realise that a browser can be changed, andd for many of them, don’t realise their browser is even called ‘Internet Explorer’ – remember that the default setup for most ISPs is to rename the IE shortcut to be something like ‘Click to Launch Bastardo Broadband’. Telling them they can upgrade is just more words on the screen, getting in the way of LOLcats or whatever – “Blah blah blah blah upgrade blah blah, OK / Cancel?” – to which the answer is “Hmmm… well… Cancel I guess – I just want to use the intarweb”.

What’s better than an upgrade option?

Simply put: no mention of the word ‘upgrade’, and no mention of the word ‘option’. Just a done deal.

You see, browsers don’t have to install in Program Files, and they don’t have to install via a lengthy and pointless install wizard. Installers can be short, quick, and not require admin privileges. I’m thinking of Chrome here. (Yes I know Firefox can run from anywhere – but that’s not typical, hence my focus on Chrome).

Instead of a banner vaguely informing users that “they’ve got the wrong browser” and “they could be free” (which are basically insulting and uninteresting statements to them), we just present the statement: “To use this website, click here”.

…Where “here” is a link to a custom Chrome (or other non-admin-install-required browser) installer, which does the following:

• Quick EULA, in case Mrs Miggins (aka “the user”) tries to sue Google;
• Browser security pop-up, which we can’t (and shouldn’t) change;
• Shows a progress window, showing install progress;
• Places a shortcut on the desktop which launches your website in Chrome;
• Finally, executes said shortcut, displaying your website in Chrome.

And so, with two clicks of “OK”, the user is now happily viewing your web app. (And who knows, maybe they’ll start using Chrome for other browsing?)

Any thoughts?

Overview

Windows Live Mesh basically allows you to synchronize files and folders between different computers. You create a central “desktop” space in the “mesh”, which acts as the central store. You can then synchronize folders on multiple computers to folders in the mesh, and any files you store in these folders will become available both to the central store, and to any other computers also sync’ed to it.

I think Live Mesh probably does more than this – remote desktop seems to be in there somewhere – but it’s very difficult to penetrate the buzzwords to find out a simple list of features.

It’s also worth noting that it’s still in beta, and therefore still a bit rough around the edges. I’m not intending this article to be harsh, or overly critical – rather any bad points listed are my informal bug reports.

Here’s the good and bad points I’ve found in a couple of days’ use:

Good: IJW – It Just Works

In general, once you’ve got your folders set up, the whole syncing thing just works automatically. Synchronization is one of those computer science problems that’s always difficult to get right (something I know from personal experience) – but Microsoft seems to have cracked it. Registering devices (computers) is easy, as is creating synced folders and attaching them to the devices.

That might seem a short paragraph for the best feature, but to my mind, “IJW” is about the best thing you can say about any application.

Good: Integration with Windows Explorer

For most of the time, you can forget you’re using Live Mesh at all. Live Mesh is integrated with Windows Explorer, so your synced folders work just like any other folder – there’s no need for a separate application. There are some visual cues to indicate they’re ‘special’ though – a toolpane is docked on the right hand side, the folder icon is a nice glassy blue, and files that haven’t been downloaded yet are faded.

Good: Live Desktop web interface

Ignoring whether mimicing a desktop interface within a web browser is a good idea or not, the web interface to your folders (“Live Desktop”) is excellent – it really is a working cut-down copy of a Windows desktop. If you have Silverlight installed you’ll get better media views, but apart from that, it will work in vanilla Firefox and IE.

I think the “Live Desktop” metaphor (plus the devices view) really reinforces the idea that the “Mesh” is an additional, virtual, computer that you own.

Bad: UI Polish

I mentioned earlier that Live Mesh is currently in beta, and in some areas it really shows. This application lacks the final ‘polish’ that’s the difference between a tech demo and a releasable product:

• Items in the “News” tab only have a time, not a date;
• Vista switches in and out of glass mode while installing;
• Windows Explorer right-click menu additions are only placeholders (they just display a help message instead of providing real functionality);
• Images aren’t displayed as thumbnails in the web viewer.

Bad: Live Login

Unfortunately, while the web desktop is nicely implemented, the rest of the “Live” infrastructure is just as shoddy and barely-working as it ever was. You can tick “remember me” and “save password” as often as you want, and it won’t work half the time. Live logins seems to take you through dozens of redirects. Want to report a bug? Trying to post on the forums will get you a HTTP 500 error. Oh and someone needs to tell Microsoft that the rest of the professional web world has moved on from having your public URIs end in “.aspx” or whatever the underlying server code is. Basically the Live login system feels clunky and difficult to navigate. (For example: the login screen doesn’t have a “sign in” button until you hover over the correct area of the screen – not very intuitive).

Bad: Marketing

I would have started using Live Mesh earlier – except Microsoft releases its new Live services in such a fog of marketing bombast that it’s hard to work out what they actually do. Apparently, Live Mesh:

“…provides a seamless “just works” experience that puts you at the center of your digital world by connecting you with the people you care about and putting you in control of your information, applications, and devices.”

Hmmm. And I suppose it cures cancer and brings about world peace too? What’s wrong with saying it seamlessly synchronizes and backs up your files?

One other problem is that Live Mesh is just one of three Live syncronization services – Live Mesh, Live Sync, and Live SkyDrive. (Seriously – I’m not making this up). How am I supposed to pick the right one, if Microsoft can’t?

Bad: Large File Syncing & Windows Explorer

One major issue with Live Mesh is that it is currently tied to both Windows Explorer, and to a Windows login account. Basically, syncing only happens when you are logged on and viewing a Live Mesh folder, and worse, if syncing a large file is interrupted (say by closing the Explorer window), then it doesn’t resume – it restarts.

This means:

• Live Mesh can’t really be used for large files (say bigger than about 100Mb);
• Live Mesh can’t be used in a server environment – which is unfortunate as it would have made a great backup service.

One other problem worth mentioning is that Live Mesh seems to use 100% CPU when syncing.

Overall

Although there are quite a few rough edges, I really feel that once it’s out of beta, it’s going to be a great service. I’ve already written a little backup batch file for a few important files, and I’m going to try inviting others to share files (such as holiday pics).

Unfortunately I’m not so optimistic about the overall Live account / sign-in system – compared to OpenID it’s a big ugly mess. Microsoft really needs to re-work it (or better still, stop trying to be in control, stop trying to “own” user logins, and start playing nicely with OpenID).