IanG on Tap

Ian Griffiths in Weblog Form (RSS 2.0)

Blog Navigation

August (2014)

(1 item)

July (2014)

(5 items)

April (2014)

(1 item)

March (2014)

(1 item)

January (2014)

(2 items)

November (2013)

(2 items)

July (2013)

(4 items)

April (2013)

(1 item)

February (2013)

(6 items)

September (2011)

(2 items)

November (2010)

(4 items)

September (2010)

(1 item)

August (2010)

(4 items)

July (2010)

(2 items)

September (2009)

(1 item)

June (2009)

(1 item)

April (2009)

(1 item)

November (2008)

(1 item)

October (2008)

(1 item)

September (2008)

(1 item)

July (2008)

(1 item)

June (2008)

(1 item)

May (2008)

(2 items)

April (2008)

(2 items)

March (2008)

(5 items)

January (2008)

(3 items)

December (2007)

(1 item)

November (2007)

(1 item)

October (2007)

(1 item)

September (2007)

(3 items)

August (2007)

(1 item)

July (2007)

(1 item)

June (2007)

(2 items)

May (2007)

(8 items)

April (2007)

(2 items)

March (2007)

(7 items)

February (2007)

(2 items)

January (2007)

(2 items)

November (2006)

(1 item)

October (2006)

(2 items)

September (2006)

(1 item)

June (2006)

(2 items)

May (2006)

(4 items)

April (2006)

(1 item)

March (2006)

(5 items)

January (2006)

(1 item)

December (2005)

(3 items)

November (2005)

(2 items)

October (2005)

(2 items)

September (2005)

(8 items)

August (2005)

(7 items)

June (2005)

(3 items)

May (2005)

(7 items)

April (2005)

(6 items)

March (2005)

(1 item)

February (2005)

(2 items)

January (2005)

(5 items)

December (2004)

(5 items)

November (2004)

(7 items)

October (2004)

(3 items)

September (2004)

(7 items)

August (2004)

(16 items)

July (2004)

(10 items)

June (2004)

(27 items)

May (2004)

(15 items)

April (2004)

(15 items)

March (2004)

(13 items)

February (2004)

(16 items)

January (2004)

(15 items)

Blog Home

RSS 2.0

Writing

Programming C# 5.0

Programming WPF

Other Sites

Interact Software

Visual Studio .NET Key Bindings, Chords, and Consistency

Tuesday 22 June, 2004, 10:01 PM

There has been a fair amount of discussion about key bindings in VS.NET, and the fact that they seem to be changing yet again in VS.NET 2005.

I have mixed feelings about this. Every time the bindings change, I've been mildly annoyed, but I've always learned the new ones, and have usually grudgingly accepted that I end up slightly preferring the new ones. Although I can't help wondering if the current set were designed by someone who knows how to play the piano. I say this because I find it quite natural to use multi-key 'chords' but I've noticed a lot of people seem to find them really quite awkward. I often wonder if the main reason I find them easy is because I used to play the piano to a reasonably good standard...

But the thing that bugs me most about the current set of bindings is the amount of arbitrary stuff you have to remember. JoeN provides some fine examples of this. (It's precisely this kind of nonsense that means I can no longer bear to use Emacs, which has these kinds of issues in droves.) As a general rule I'm fine with the shortcuts I use regularly, but the lack of consistency means that it's all too easy to forget the slightly more obscure bindings. For example, it seems like the time it takes me to forget the binding for the Solution Explorer is approximately half a day less than the usual interval between each use of that shortcut...

Consistency, Consistency, Being Consistent

I'm all in favour of anything that improves consistency. One of the things I like about the .NET Framework is that in a lot of cases I don't have to remember exactly how each API works - I can just guess how it will probably work, and the reasonably high degree of consistency means that these guesses tends to be right most of the time. So I'm a big fan of Brad Abrams' efforts to ensure consistency in .NET class libraries that emerge from Microsoft, and I think it's great that they are giving 3rd party component developers the necessary tools to do the same. For me at least, this consistency is a major productivity boost - I don't have to spend my whole time looking up the documentation to deal with API-specific idioms.

Given the choice, I therefore typically prefer a breaking change that fixes inconsistency to the alternative of preserving backwards compatibility at all costs. (So this is more or less the opposite of what Joel Spolsky infamously described as the Raymond Chen approach.) But I do of course see the importance of not breaking existing code, so I understand that changing platform APIs after they're published would be a bad idea. But changing things other than the platform in order to improve consistency is surely pure goodness. Changing key bindings doesn't break anyone's code, so that should be a no-brainer.

So if new key bindings really are an improvement, bring 'em on!. But like Craig, I would like to know how methodical the thinking behind these new bindings really is - if they're going to change again, it would be good to know that every effort has been made to make them as consistent and learnable as possible.

Copyright © 2002-2013, Interact Software Ltd. Content by Ian Griffiths. Please direct all Web site inquiries to webmaster@interact-sw.co.uk