For example (error checking removed for simplification), consider the serialization of this collection.

	CMap		threadObjectStatistics;

Saving

	CSingleLock	lock(&threadObjectStatisticsSect, TRUE);
	POSITION	pos;

	ar << threadObjectStatistics.GetCount();

	pos = threadObjectStatistics.GetStartPosition();
	while(pos != NULL)
	{
		runningObjectManager	*rom = NULL;
		DWORD			threadID;

		threadObjectStatistics.GetNextAssoc(pos, threadID, rom);
		ar << threadID;
		rom->save(ar);
	}

Loading

	CSingleLock	lock(&threadObjectStatisticsSect, TRUE);
	DWORD		i, count;

	ar >> count;
	for(i = 0; i < count; i++)
	{
		runningObjectManager	*rom = new runningObjectManager();
		DWORD			threadID;

		ar >> threadID;
		rom->load(ar);
		threadObjectStatistics.SetAt(threadID, rom);
	}

In the above code the first item saved/loaded is the number of objects in the CMap. After that the thread id and the complex object associated with the type is saved/loaded for each pair of objects in the CMap. The code above uses a DWORD to load the size. This won’t work for x64 because the count of objects is taken directly from the GetCount() method (or GetSize() for some collection types).

	ar << threadObjectStatistics.GetCount();

x86, return type is DWORD, count is saved as DWORD (32 bit)

x64, return type is DWORD_PTR, count is saved as DWORD_PTR (64 bit)

This is a problem because the loading code is expecting a DWORD.

	DWORD		i, count;

	ar >> count;

Update (23/4/2012): Turns out the same issue affects the STL collections as well. If you are directly serializing the result from the size() method in an STL collection you will be faced with the same problem as I describe for MFC.

Solution 1

One solution is simply to change the type being loaded from a DWORD to a DWORD_PTR.

	DWORD_PTR	i, count;

	ar >> count;

Solution 2

An alternative solution is to always save the size as a DWORD.

	DWORD		count;

	count = (DWORD)threadObjectStatistics.GetCount();
	ar << count;

Conclusion

You may think this is a trivial issue and why write a blog post about it? I agree the actual problem is trivial and the fix for it is also trivial. However the fact that you have a mismatch in datatypes being serialized because you directly serialized the return value from GetCount() is not so obvious. So much so that this particular issue escaped our attention (and got past a static analyser) until today.

So yes, its a trivial problem but its a hidden problem and it will cause all sorts of issues during serialization and when you go looking for it you'll probably look straight past it for a while. Hopefully I've just saved you a few hours of banging your head on a brick wall, or more likely your desk.

You may think that good communicators are slick, polished, don’t make mistakes, can sum things up nicely and exude a certain level of confidence. Well yes, the public speakers that have been around for a while do tend to be that way. But that is more the result of speaking in public many times than natural ability. Eric Ries wasn’t as polished when he started speaking in public. He is the first to admit that. Practice makes perfect.

That isn’t want I’m talking about. I’m asking you if you communicate your ideas to others and if at the end of the conversation do they understand you?

Why am I mentioning this? Years ago I had a performance review by my line manager. The review was done in 3 parts. My manager would fill in his scores for various tasks and abilities, rating me. I would do the same. Then we’d compare the scores we had for each task and discuss the differences/similarities and how to improve any areas that needed improvement and how to make the most of areas I excelled at.

There were lots of categories, none of which I can remember except for “communication”. I don’t tend to award myself a 10 or 1 in anything when I self score, so the sheet had various high scores and a few low scores. I was hitting it out of the park in software development terms (which would come back to bite me a few years later in the form of RSI – my work was 3 months ahead of schedule) but for communication I gave myself a really low mark.

The really low mark for communication confused my line manager and we spent a good chunk of the review just talking about communication. I had interpreted “communication” on the form as “Can I present, Do I speak in public, do I do this, that the other…” all these imagined things that I thought a good speaker should do. I didn’t think I could do them.

My line manager wasn’t interested in that. He was interested in did my team mates, colleagues, people in teams interfacing with our team (in person or via our documented API), senior managers etc, did these people understand the technical work I was doing? Did they understand how to use it, why certain things were the way they were and most importantly if someone came and asked me a question could I answer it with confusing the living daylights out of them?

Turns out I could. I scored quite well on all that. No idea what he wrote down. Not really relevant these days.

All I’m trying to say is communication is making sure the other person understands. Far better to be slightly slower, or more verbose, or elaborate (or whatever) and succeed in communicating than be super concise, uber terse, abrupt and leave the other person feeling bewildered or intimidated by what you’ve just said.

How do you feel about communication now? Think you’re better at it than before reading this?

Why 16 bytes?

At the time it seemed odd to me that the stack had to be 16 byte aligned. Why? All the parameters are 8 bytes (64 bits) wide and the first four are passed in registers. Everything else spills onto the stack and anything larger is passed as a reference. Floating point values are passed in dedicated floating point registers.

And there lies the key. That last sentence. The floating point registers.

Floating point on x64 is not done using the floating point coprocessor instructions. Instead the SSE instruction sets (and its extensions) are used.

If everything floats, whats the point?

If you are just hooking x64 functions and possibly collecting callstack you may never know need to know about floating point register preservation. We managed to get all four of our C++ tools (coverage, memory, profiler and deadlock detector) functional without knowing. Why would we need to know? Floating point preservation was never important for x86 because we could never damage the floating point without trying to do so.

But when we got into the details of the last bugs that were killing us we noticed seemingly random crashes. Closer investigation showed that calls to Win32 API functions had a tendency to wipe out the floating point registers. And that is when we got interested in what happens if we preserved the x64 floating point registers.

How to view the registers?

At first glance this wasn’t obvious to me. The Registers window in Visual Studio just shows the registers from RAX through R15 etc. However if you right click this window there is a helpful context menu that allows you to choose just how much information you display in this window.

Once you have the registers in view things get a lot easier inside the debugger. You can step through your code ensuring that nothing is getting trampled on until Viola! the floating point registers get totally hosed. A bit more investigation and you realise that seemingly innocent call you had in your code contains a call to a Win32 function (for example VirtualProtect) and that that function is responsible for the register death.

OK, so how do we preserve registers on x64? Its nothing like on x86.

x64 floating point preservation

The x64 designers in their infinite wisdom took away two very useful instructions (pushad and popad). As a result x64 hook writers now have to push lots of registers and pop lots of registers at the start and end of each hook. You can even see this in parts of the Windows operating system DLLs. So much simpler just to push everything and pop everything.

However what the Lord taketh away he can give back. And the x64 designers did that by providing two dedicated instructions for saving and restoring floating point. fxsave and fxrstor. These instructions take one operand each. The operand must point to a 512 byte chunk of memory which is 16 byte aligned.

A common usage would be as shown below although you can use any register as the destination location. It just so happens that the stack pointer (rsp) is the most common usage.

	sub	rsp, 200h;
	fxsave	[rsp];

	.. do your task that damages the floating point registers

	fxrstor	[rsp;]
	add	rsp, 200h;

When you see the above usage you can see why there is the requirement for the stack to be 16 byte aligned. Why 16 bytes? I suspect it is because it is the start of a cache line and that makes executing the instruction *SO* much quicker.

Conclusion

So now you know why the x64 callstack is 16 byte aligned. Its all to do with ensuring your code executes as fast as possible, especially when executing a memory intensive register copy when saving and restoring the x64 floating point registers. I’ve also shown you how to preserve and restore the floating point registers.

A few days ago I was testing the latest version of C++ Memory Validator x64.

The testing was going fine until I tried testing a particular test tool of ours. C++ Memory Validator x64 would inject into the test tool, start injecting then just die at some point.

No problem, just set the injection flags to inject a breakpoint and that’ll trigger the debugger as soon as we inject. This works with most software and with all our test tools. No joy. Hmmm, puzzling.

OK, try again, but when we get to CreateProcess() I’ll attach the debugger to the paused process myself. That’ll work. Right? Wrong. The debugger does attach and thats great. I resume the process and the the debugger spits out a really impenetrable error message.

“Debugger:: An unhandled non-continuable exception was thrown during process load”.

That is a really useful and useless message all in one.

Next steps

One possible next step would be to repeat this sequence but before resuming the application, go to the debugger and open the Exceptions dialog from the Debug menu.

When the Exceptions dialog is displayed go to the Win32 exceptions part of the settings and expand it so that you can see the various exceptions that will be reacted to. We need to tell the debugger to react to some of these exceptions. I’ve included screenshots with the exceptions highlighted. Feel free to enable other exceptions that you think may be troublesome.

Having enabled the appropriate exceptions you can resume the process and see if the debugger reacts to any of these more obscure exceptions.

Solution

It turned out the problem was a DLL dependency was failing and thus resulting in a module not found exception.

In my case what had tripped me up was that we’ve been doing static analysis of our software recently using PC-Lint from Gimpel Software combined with Visual Lint from Riverblade. PC-Lint does the hard word of analysing your source code and Visual Lint organises the mountain of results into useful and usable information. If you’ve ever seen the log file from PC-Lint you’ll understand the benefits of a tool like PC-Lint to organise the results.

The result of the static analysis is that we’ve changed many APIs. Many objects that were passed in as objects (and implicitly incurred object copying penalties) are now passed as const references. Many char * strings and wchar_t * strings are now passed as const and so on. We’ve done this all over – changing our DLL APIs, everything.

It’s great, we’ve found bugs because of this. Really useful. But I digress. One side effect of this is that the anything dynamically or statically linked against our libraries now fails to work. We had rebuilt all the dynamically linked tests but forgotten the statically linked one. The test I was performing was statically linked.

Rebuilding and relinking the statically linked test meant that the DLL imports/exports now resolved and the DLL would load. Problem solved.

The change to our APIs is a one time change and will be painful for the folks that use our linkable APIs, but the benefits are increased software robustness for everyone, ourselves and customers alike.

There is a small overlap between the types of bugs that static analysis and dynamic analysis can find. Static analysis will find some of the bugs dynamic analysis finds, but static analysis will also find bugs that dynamic analysis cannot find and dynamic analysis will find bugs that static analysis can’t find. In summary you should have both static analysis tools and dynamic analysis tools in your software tool box.

Tools

If you look around the web you will find a variety of tools, some open source and some commercial. The commercial tools range from the sensibly priced Gimpel PC Lint to tools that are so expensive you need to be sending rockets into space to afford them. For these products where the vendor does not list the price on the website, we have listed POA in the table below. POA means “Price on Application”, which you can think of as code for “very expensive”.

One other thing, most of these POA tools only license you for using the tool for one year. After that you have to buy the software again (not maintenance, but the right to use the software again). So they are even more expensive than you think.

This is not an exhaustive list of tools. There are many more, especially if you look outside of C/C++.

In addition to the above tools there is also a Visual Studio addin (Visual Lint by Riverblade) that can manage many of the above tools and provide you with a very usable, nice interface to the mountains of data some of these tools can generate. Visual Lint is not actually a lint or static analysis tool. Visual Lint’s job is to organise the output of the static analysis tools.

Our static analysis history

Several years ago we thought getting a static analysis tool would be a good idea. We approached several tool vendors and drew a blank. The prices were astronomical – Coverity (based on their standard pricing) would want $5.6 million (for a one year, single user license) if I remember correctly. An email exchange with them revealed they would provide a discount but the price was still more than half a million dollars. We approached Klocwork but their reseller was only interested in selling us a five user license when we only wanted a single user license. I think that was $20,000 for a one year license.

We had previously used Gimpel PC Lint, but found it very hard to configure. Then we found Riverblade’s Visual Lint which is an addon for Microsoft Visual Studio. Visual Lint works with many other analysis tools and provides a nice visual front end for viewing the output of the other tools. For us this was perfect as it worked with Gimpel PC Lint and configured it correctly out of the box. No messing with Gimpel PC Lint to make it work with our Visual Studio builds.

We have been analysing our software using Visual Lint recently. We haven’t found a lot of bugs, but it has revealed subtle signed/unsigned conversions, some logic errors, redundant code and some code that could (in the right conditions) manifest as bugs. It also reports various issues that you may regard as coding style issues. One of the coding styles I hate is the call a function, assign its return value and test a conditional all in one.

    if (!(fResult = ETPhoneHome()))
    {
        RideBicycleIntoSpace();
    }

How much clearer to write:

    fResult = ETPhoneHome();
    if (!fResult)
    {
        RideBicycleIntoSpace();
    }

The compiler will generate the same code, but the second is easier to read and should you need to debug it, the second version is easier to debug. Disk space is cheap. There is no reason to code in the style of the first version. As such the informational warnings like this can be used a mini-style guides. Fix the issue to remove the informational warning from the tool output.

For any warning you don’t agree with or don’t care about you can filter them out.

I must say that I’m very pleased with the outcome of this exercise. I can recommend the combination of Gimpel PC Lint and Visual Lint. Finding these bugs so easily has paid for the software tools used to find them.

Unusual benefits

I’m going to list a few things the PC-Lint/Visual Lint combination warns about which I’ve found beneficial.

Variables not initialised in constructors and functions.

Easy mistakes to make. Often caused by logic errors rather than forgetfulness.

Unused variables, unused functions and unreachable code.

Variables you once needed, left behind after edits, cluttering the place up. Same for debugging function and historically obsolete code. Useful to know what you can safely remove. A word of caution though – be sure to check for conditional compilation excluding the code for the lint analysis. Lint can get this wrong sometimes.

Incorrectly defined copy constructors and assignment operators.

I’ve found these to be a boon. The previous constructors and operators worked OK, but better to have them in the style that STL will expect.

Lack of const

Before:

void myFunc(char *title);

void myFuncRef(CString &title);

After:

void myFunc(const char *title);

void myFuncRef(const CString &title);

These are minor wins as this change only gets suggested if Lint can determine that the parameter is not modified. However it is a win for the rest of your software as you can now pass const objects into these functions without casting them to none const (ouch!) and also know that the function, if modified to modify the objects will not compile properly. So it is a useful maintenance win.

Change from pass by value to pass by const reference.

Before:

void myFuncRef(CString value);

After:

void myFuncRef(const CString &value);

This is a major win. You get the maintenance wins from the previous example plus you get a CPU saving because there is no implicit object copying happening to pass the value into the function. In the case of complex objects (like CString) which allocate memory on construction and destroy memory on destruction there you save even more CPU cycles because the memory manager is not called. Additionally you are less likely to fragment the heap because the heap is used less. Win, win, win!

You definitely want to be making changes like this. Visual Lint will tell you stuff like this in its results.

The only downside to these changes are that you need to rebuild after the changes. If the changes are in a core header file or a class that many files use you’ll spend a while rebuilding. But this pain is short-lived. You’re making the software more robust in the process and long term that is a worthwhile trade off.

Pricing

I think most static analysis tool vendors are missing a huge opportunity. By pricing themselves so expensively most software houses will not purchase such tools. Then to compound matters they make it a yearly subscription so you have to spend the full price again each year. When I look at purchasing software the first thing I look for is a published price list. I’m not overly concerned with the prices until I’ve tried the software, but if the prices are not listed I don’t even bother evaluating the software because I know the price will be too high. It’s a waste of my time evaluating a tool, finding that I like it only to find out it’s $20,000 per year per user to use.

Any company that chooses to price their tools so they are affordable to software developers (in the $200 – $1000) range will have a much better opportunity for these tools. From what I can see only Gimpel and Riverblade have taken this route.

Conclusion

If you are not using static analysis tools I recommend that you spend some time investigating such tools. The free tools have their pitfalls – incomplete implementation and they don’t always have support. CppCheck seems to be highly thought of. If you are using Gimpel PC Lint or want to use a lint then I recommend Visual Lint for use with Visual Studio. If you have the budget then check out the POA tools in the table above.

Some people make the mistake of thinking that static analysis tools replace dynamic analysis tools (like C++ Memory Validator, etc). Static analysis tools complement dynamic analysis tools. There is a small middle ground where some bugs will be identified by both a static analysis tool and a dynamic analysis tool, but each group of tools can identify whole classes of bug that the other tool cannot identify.

If you are a tool vendor listed above please let us know your pricing and/or licensing terms if this article lists it incorrectly.

If you are not using MFC but using another framework or set of classes that provide similar functionality you can often find similar functions in those classes that will allow you to get a similar benefit to what I will describe in this article.

The Problem

The problem is the typical use of populating the array is by calling the Add() method to add something to the array. No actual problem with that, its simple and straightforward enough. However, under the hood, each time you call Add() the array class has to reallocate more memory of the data stored in the class.

This reallocation has a cost. The cost is increased CPU usage as suitable memory space is searched for by the memory allocator and memory is copied and reassigned inside the class. For small arrays this is not really a problem.

However for larger arrays this becomes quite a noticeable issue. In addition you also run into potential memory fragmentation issues, where memory "holes" of an unusuable size are left in the memory managed by the memory allocator. Should enough of these holes occur you can suffer out of memory conditions even when Task Manager tells you you have available memory. Frustrating! I’ll cover Memory Fragmentation in a different article.

Here is a (simplified) example of the type of problem:

// read data from the serialization archive and store in an array

DWORD i, n;

ar >> n;
for(i = 0; i < n; i++)
{
    someClass *sc;

    sc = new someClass();
    if (sc != NULL)
    {
        sc->load(ar);
        array.Add(sc);
    }
}

The Solution

In the case shown above we know how many objects we require storage for beforehand. This means we can tell the array how many objects to store and only perform one memory allocation to set aside storage for the array. This has CPU benefits and also because there are no repeated calls to reallocate the memory the likelihood of fragmentation occurring diminishes dramatically. In many cases, completely removed from the scenario.

To set the size beforehand we need to call SetSize(size); and to place data in the array we no longer use Add();, but use SetAt(index, data); instead.

Here is the reworked example:

// read data from the serialization archive and store in an array

DWORD i, n;

ar >> n;
array.SetSize(n);
for(i = 0; i < n; i++)
{
    someClass *sc;

    sc = new someClass();
    if (sc != NULL)
    {
        sc->load(ar);
        array.SetAt(i, sc);
    }
}

For large volumes of data the above implementation can be noticeably faster.

Caveats

When you preallocate memory like this you must be aware that if you don’t fill all locations in the array using SetAt() you may get errors when you call GetSize() to get the array size and GetAt(i) to retrieve data.

// read data from the serialization archive and store in an array
// we won't store all data, leaving some unused memory at the end of
// the array

DWORD i, n, c;

ar >> n;
c = 0;
array.SetSize(n);
for(i = 0; i < n; i++)
{
    someClass *sc;

    sc = new someClass();
    if (sc != NULL)
    {
        sc->load(ar);
        if (sc->IsEmpty())
        {
            // discard

            delete sc;
        }
        else
        {
            array.SetAt(c, sc);
            c++;
        }
    }
}

GetSize() will return the size of the array you set when you called SetSize(), this is not necessarily the number of items in the array – this will come as a surprise to people used to adding data by calling Add().

To fix this, use FreeExtra() to remove any unused items from the end of the array. You can also use GetUpperBound() to find the largest index that is used by the array. The example below shows this.

// read data from the serialization archive and store in an array
// we won't store all data, leaving some unused memory at the end of
// the array

DWORD i, n, c;

ar >> n;
c = 0;
array.SetSize(n);
for(i = 0; i < n; i++)
{
    someClass *sc;

    sc = new someClass();
    if (sc != NULL)
    {
        sc->load(ar);
        if (sc->IsEmpty())
        {
            // discard

            delete sc;
        }
        else
        {
            array.SetAt(c, sc);
            c++;
        }
    }
}

// make sure array.GetSize() returns the max number of items used

array.FreeExtra();

Twitter seemed to come into its own at and before the conference. People using phones, iPads, laptops to coordinate who they were eating with and when. #BoS2011 became unmanageable. Mark Littlewood’s advice to use Tweetdeck was well received.

Audience

Its a self selecting audience. They’re all very bright, self motivated. A lot of the people attending run their own businesses, from one man companies to some larger organisations like Red Gate who brought a good chunk of their staff with them. 30 people? 50 people? I don’t know. A lot – more than many people have on their entire staff. I spent Saturday evening with 5 Red Gate people and most of Sunday with some more Red Gate folk. It seems that Red Gate is being quite entrepreneurial with its staff – exposing them to conferences like this and training them for the future. It seems like a much more thoughtful vision for their future than most companies take.

Microsoft had some people in attendance too. The only Microsoftee I met was Patrick Foley, who was brave enough to give a Lightning talk. One attendee had travelled all the way from Romania, using three planes to get to Boston. He was probably one of the youngest attendees too. I spent a chunk of Tuesday evening chatting with him in The Whiskey Priest. Not sure I’d have been that keen to travel that far for a conference at age 25. Kudos.

The quality of the speakers was incredible. I thought Clayton Christensen would be the top draw (I’ve read most of his books, found them really interesting) but as it turned out I preferred the speakers on the second day – Rory Sutherland and Josh Linkner in particular. Most speakers manage to weave humour into their talks. I don’t know if this was planned, opportunist or just something you get good at.

Note taking

I typically record each speaker so that I can listen to them again. Unfortunately for me, although armed with loads of AA batteries when it came to record day two they all failed. So I couldn’t record what turned out to be my favourite talks. Next time, purchase the batteries when I get there, don’t rely on them being OK just because they’ve never been used.

Although at MicroConf I took copious notes, I took very few at Business of Software. I was just too wrapped up in what was being presented. When I look at my notes its in my typical unreadable “I should have been a doctor” handwriting, with a good chunk of the notes not about the talk being given but about ideas for improving the software process at Software Verification. Its as if being there was stimulating me to take action over what we will do in future. Part of me is pleased with this and part of me is frustrated I didn’t take more written notes.

The Business of Software goodie bag was unusual – full of stuff I will actually read. Books from some of the speakers. Their talks were interesting, so that bodes well for the books they wrote.

Business of Software Team

The team Mark Littlewood assembled were superb. They were always on hand to help. When I asked them for help with some nuts (I needed protein as the vegetarian food was all carbohydate and had no pulses etc) they to my amazement found some fruit and nuts for me. I expected them to tell me where I could find a shop. Later that evening two of them saw me collasped on a seat at The Whiskey Priest and came over. They wanted to walk me back to the hotel until I explained I’d be alright in about 20 minutes – when my blood sugar had become normal again after eating (I shouldn’t have had the beer so soon after eating with the noise of the Business of Software band – too much).

As well as the BoS team, the conference centre staff were helpful and courteous. Americans really understand service. So often I’ve had bad experiences in the UK.

Clayton Christensen

Clayton Christensen’s talk was pretty much a summary of his Innovator’s Dilemma book. Given that I’ve read his books I didn’t talk many notes. I think the standout items for me were:

• The customer rarely buys what the company thinks it is selling him.
• You should be focussing on “What is the job to be done (by the customer)?”.
• Look to the bottom of the market, that is where the innovation will come.

The second point is really telling. Most companies create products they try to sell to customers. They don’t actually research what it is a potential customer is trying to do. Are you really trying to buy a car or just go from A to B conveniently? If its the latter a car may not be the best thing to sell them. On this point, in Cambridge, UK, there has been a rise in the number of people ditching their car and switching to electric bicycles. Job to be done is commuting around town. You don’t necessarily need a car for that.

This third point was illustrated nicely with the example of solar power. In the USA and Europe we have government grants creating solar power and wind farms. But that is trying replace the existing fossil fuel based systems with intermittent solar and wind power. But if you go to Africa and parts of Asia where there is an underserved market (people with little or no power supply) then an intermittent supply of solar and wind is more useful than no power supply. It is in these markets that new technologies to improve the intermittent power supply (with better battery technology for storage and better solar cell technology for improved generation, etc) can flourish. Eventually these technologies will get good enough to start competing in the more traditional markets for power in the Western economies. The key thing is that the economic drivers are in the underserved markets, not in the well served markets.

More Information: http://www.claytonchristensen.com/

Jason Cohen

Jason Cohen talked about Honesty and how companies misrepresent themselves to make themselves appear different from reality. A bit like a bird puffing up its chest to look more intimidating we write our about pages to appear different than we really are.

Jason argues that this is dishonest and misleading and that by being honest it is more profitable in the long run (and feels better). Jason also argues that by being candid about what you can and cannot do you also inform your customers better than the one-sided comparison charts (where every feature your software can do is listed and only your software gets a tick mark next to everything).

Jason sold his previous company and now runs a WP Engine. WP Engine is smaller than most of his competitors and as Jason admits, he isn’t the cheapest solution. However he believes that by being candid about your strengths and weaknesses your company size doesn’t have to be a weakness. You size means you need every customer, thus you must focus on them. Contrast this to the approach you get from Big Corp, where you are a faceless customer and often get treated like one.

I wrote two quotes during the talk:

• “Truth in limitations earns believability advances”.
• “Open source is free like a puppy is free”.

I had two todo items on my list at the end of this talk and a big note saying I must re-listen to this talk when I get home. It made an impression. Dave Collins from Software Promotions was so impressed he wrote a post about it then posted the before and after About pages so you could see the difference.

More information: http://blog.asmartbear.com/

Alex Osterwalder

Alex Osterwalder gave a talk on Business Model Generation. I had thought Alex’s talk would be boring. And talking to some people later on (in the UX class lead by Richard Muscat) it appeared some other attendees also thought that. How wrong we were. One of the books in the goodie bag was Alex’s book on Business Model Generation.

On the face of it the title “Business Model Generation” sound rather dry. Alex demonstrated how to use a simple business model canvas to enter simple facts and figures about your business then use those to create other information you could use to see if the business is viable. If not viable, change some parameters and see if the new model is viable. It was surprisingly simple and easy and by the end of the talk I got the impression people wanted more.

To demonstrate a business model Alex used the Nespresso coffee making machines as an example.

• The machines are sold in retail outlets.
• Most of the profit from sale of machines goes to the business partners.
• Nespresso make their money from sales of the coffee pods by mail order, nespresso.com, call centers and from nespresso stores. These are all distribution channels owned and controlled by Nespresso.
• This allows Nespresso to keep all the recurring margins.

This talk also introduced the audience to Stattys, a non-sticky note that uses static electricity to stick to things rather than glue. After Business of Software Paul Kenny resorted to some awful puns because he liked Stattys so much.

Later on I was in the UX workshop (where we redesigned Business of Software) and talking with other attendees I found that my subgroup in the workshop all wanted to be in the Business Model Generation workshop but all of us had excluded that workshop because we thought it would be boring. None of us held that opinion after Alex’s talk.

Alex also demonstrated his iPad application which is a software implementation of the business model canvas. Looks quite slick and certainly an easy way to create and explore different business concepts.

More information at http://alexosterwalder.com/

Dharmesh Shah

Dharmesh spoke about customer retention and how to measure it, and pricing.

4 Churn Types:

• Customer. e.g. 5% 5 out of 100.
• Revenue. e.g. 10% 20K out of 200K.
• Discretionary. People cancel their account.
• Involuntary. Billing failure causes cancellation.

At Hubspot they use the Custom Happiness Index 2.0. This predicts how well the customer uses the software.

Dharmesh argues against Freemium pricing as this is a sunk cost. Instead if you want to do Freemium but without the sunk cost you should do Cheapium which is where you charge the customer the cost of supporting them. You don’t make any profit with Cheapium, but you also don’t lose money with Cheapium and you may convert some Cheapium customers to paid customers.

You need humans to sell Complex Products, New Products and products where the price is somewhat high (which Dharmesh defines as greater than $100/month). The point of indifference for most customers is between $30/month and $40/month.

More Information: http://onstartups.com/

Jeff Laswon

Jeff Lawson gave a talk on “Saas Mating Calls” and value as perceived by the customer.

I don’t have many notes on this talk. The talk was somewhat ruined by a couple of people persistently talking behind me until I take no more and asked them to leave or shut up. I was so wound up by this point that I couldn’t really concentrate on Jeff’s talk. I found out later that many other folk had also been annoyed by these two people (perhaps they had not spent their own money to attend?).

So, sorry for no notes worth commenting on.

Tobias Lütke

The last talk of day one was by Tobias. Again, I don’t really have many notes. I think I was struggling with low blood sugar.

Tobias talked about the culture of your company. What sort of company do you want to build?

“Do not start a company to make money. Start a company to delight customers.”

Patrick McKenzie

Patrick McKenzie talked about sales funnels and A/B testing. He also revealed an engagement ring he was going to present to his girlfriend when he returned to Japan.

Sales Funnels:

• Describe the Funnel.
• Measure the Funnel.
• Optimize the Funnel.
• Profit!

Shorter funnels are better. Analyze your funnel. If you can find any un-needed steps in the sales funnel, remove them.

A/B Testing places:

• Home Page
• Landing Pages
• Pricing Page
• Shopping Cart

Test the following:

• Headlines
• Offers
• Calls to Action
• Prominent graphic elements
• Important micro-copy – address customer objections.
  
  Example “Don’t worry, we won’t spam you” next to an email address field.

Patrick recommends doing the A/B testing yourself so that you have the test data, but if you don’t want to do that use Visual Website Optimizer (Note: Dharmesh also said Visual Website Optimizer is good when I talked to him about Hubspot – even though Hubspot now has Performable’s A/B testing suite). Be systematic about A/B tests. It works. He says it “prints money”.

Purchasing page
Change your purchase page to do purchasing only. Remove all un-necessary links from the purchasing page so there are no distractions. I suspect this advice is much more important for B2C websites than B2B websites.

First run experience
Collect first run experience statistics. How many people run your software once? How many people run it twice?

If you know the search terms for an evaluating customer find a way to provide customised startup help for that search time on the first run of the software.

Tour Mode
Find a way to provide an interactive tutorial to lead people through the steps to use your software effectively. This is called Tour Mode.

Telemetry
If you do gather telemetry from your desktop software be sure to ask the user’s permission to send that data back to your servers.

More Information: http://www.kalzumeus.com/

Laura Fitton

Laura talked about how your communication to your customers and potential customers should Be Useful.

Be Useful. Its not about you. http://inay.org

Laura advocates a sequence of actions you can use to be more useful.

• Listen
• Learn
• Care
• Serve
• [repeat]

Laura’s presentation is on www.slideshare.net/pistachio.

Recommended book: Content Marketing for Startups by Dan Martell.

More information: hubspot.com/pistachio

Josh Linkner

Josh Linkner is VC. He didn’t talk about funding or finance. He gave an excellent talk on unleashing your creativity. His book Disciplined Dreaming was part of the Business of Software Goodie bag.

Josh started by giving a background to creativity and explaining that although most of us think we are not creative, creativity is 85% learned behaviour.

Blocks to creativity are fear. Fear of failing. Fear that the idea/design won’t be any good. I’ll also posit that for a few people, they are afraid the idea/design will succeed and they will have to follow through.

Be curious. Make a point of being curious. Ask Why? Why if? Why not?

“Fail more to win more.”

Do not criticise small mistakes.

Encourage experiments, tolerate failure.

Remarkably Different
Josh gave an example of an unusual and creatively inspired business – http://www.littlemissmatched.com/ – where you can only buy socks in odd numbers. The socks don’t match and you can’t buy pairs. It’s a roaring success. It’s remarkably different.

5 Whys
Josh recommends using the 5 Why’s technique. Ask “Why is this?” about the topic. Then repeat for the answer. Do this 5 times to get to different insights about what you are looking at. This technique is used in quality control, user experience design and other fields. You can use it creatively too.

Learned behaviour
Josh demonstrated learned behaviour by describing an experiment known as The Pike Syndrome where a carnivorous fish (A Pike) ignores the prey fish because it had earlier learned that it was unable to eat them. In the same way, although creative during childhood, many things during our adolescent years and adulthood teach us not to be creative. But you can learn to be creative.

Role Storming
Another technique Josh uses to encourage people to be creative is to “Role Storm”. This is where you take on the role of a particular person or character and approach the problem from their point of view. For example what would Business of Software be like if Darth Vader hosted it? What benefits and features would he be interested in? What sort of user experience would Darth Vader be expecting?

Captcha
Josh demonstrated an alternative form of captcha that relies on understanding a caption and then acting upon it with a simple game. The layout of the game changes on a regular basis as do the captions. This makes it almost impossible for a bot to defeat the captcha. The example given was “Drag 3 peppercorns and 2 mushrooms onto the middle pizza”. It’s an inspired bit of creativity by taking the original problem and re-framing it.

Suggestion
Take 5% of your time (2 hours) to be creative each week. You will be more productive.

I’ll be posting more on creativity as I compose tunes and people always ask me how I do that as it must be so hard and complex. Wrong! Its easy. Anyone can do it.

More information: http://joshlinkner.com/

Rory Sutherland

Rory Sutherland is Vice Chairman of Ogilvy, the advertising giant. Rory gave a talk about Praxeology, the study of human action. Rory talked about how creativity and rational thinking don’t necessarily go hand in hand. Rory was hilarious and the talk full of interesting nuggets.

I’m afraid my notes don’t do justice as I appear to have written short snippets to jog me into performing Google searches. As such I’ll list the phrases here and if any of them jog your mind or cause you to search then that is more use than me trying to frame them for you.

Creativity is policed by rationality but rationality is not policed by creativity. This can lead to very creative people being prevented from being creative but leave rational people to create things like the finance and banking meltdown that happened a few years ago and which we are still living through now.

Chunking
If you want people to finish a task, split the tasks into chunks. People are much more likely to complete all tasks if approached this way.

You want your customers to avoid disappointment or complete surprises.

Rory introduced Ludwig von Mises and the subject of Praxeology.

Do not distinguish between subjective and tangible value.

Availability
Signalling
Handicap
Hueristics and biases
Framing, comparison and content
Immediacy
Loss

Information asymmetry and commitment.

Satisficing vs Maximising.

Make choosing easier
Choice making is easier with 3 items than with 2 items. Put the best choice in the middle and create cheap, average, expensive choices. Most people will choose the middle one.

Framing
Framing is all about the context in which you see the offer. Every thing is relative.

Reduce web steps from three to two improves conversion by approx 40%.

Resolve discomfort and disquiet to improve sales.

Behaviours lead attitudes.

Book: Ash Murya.

Lightning talks

I didn’t take any notes on the Lighting talks.

The most memorable talk for me was Tyler Rooney’s talk about the failures he witnessed and experienced at Amazon. The most hilarious being someone nobbling the companywide internal DNS, which killed everything. Including killing the IP-based telephones so that nobody could contact anyone to tell them to fix the problem. Sometimes economies (like purchasing IP based phones) are not economies.

Justin Goeres won the Lightning talk competition, so I never did bump into him (we were going to go for a meal later) because he was invited to the Speaker’s Dinner. Would he pass that up for a meal with me? No… We finally met up at breakfast the next morning.

Michael McDermott

The next talk was about being a design dictator at Fresh Books. I didn’t take any notes. I think I was struggling with low blood sugar.

Fresh Books is a good product. We use it.

John Nese interviewed by Peldi

The final talk of day 2 was John Nese, the owner of an independent Soda Pop store being interviewed by Peldi. The interview was prefaced with a video. John Nese was fantastic. The little guy going against Big Corp (in the form of Coke and Pepsi). He had passion to spare and a true depth of knowledge about the products he sells, strong opinions on stuff he doesn’t like (Energy drinks and stupid recycling laws).

After the talk everyone was talking about him. Strong resonance between what he had to say and how most people felt business should be done (rather than how it often is done).

Paul Kenny

Paul talks about how to close a sale. How not to leave the sale dangling and how to not ruin the close by closing in the wrong way. Closing is a soft skill and not something that you can deal with in terms of cold hard data.

How many people in the audience are founders? Lots of hands. Good. “You are a founder. Therefore you are a salesperson.”

“The result of a business is a satisfied customer.”

How not to do it: Alec Baldwin (always be closing).

Closing is asking for a commitment. Commit to what?

• Concept
• Action
• Purchase

Asking avoids the decision making process. (can’t read my handwriting, I think it says “avoids”).

Mistakes:

• Ask the wrong way at the wrong time. (push)
• Fail to ask the right way at the right time.

People are pushy when the have only one way of asking.

Once you have asked for your commitment, shut up and wait for the answer.

David Cancel

David Cancel talks about A/B tests. David’s company Performable was acquired by Hubspot in late 2010/early 2011.

Failing is good. It is OK to fail. You learn by failing.

He recommends having a business dashboard so you can measure your company’s health.

All initiatives should show improvement.

Use the Net Promoter Score to measure satisfaction.

If using multi-variate tests, don’t bother if you are a small company.

David thinks 2% is average percentage conversion rate. (this is out of context).

Alexis Ohanian

Alexis Ohanian talked about different ways of making the world suck less.

I didn’t take any notes in particular except to remind me to give some of my time away to a local charity.

He also gave away an Apple MacBook. The two people that came up with winning entries both said they didn’t want or need the MacBook, so it was given away to a public school in Melrose, Boston and a local programmer has agreed to teach at a local class.

Workshops

I attended two workshops at Business of Software.

The first workshop was by Richard Muscat from RedGate. This was a user experience workshop where we created user empathy maps for one member of a group of 5 or 6 people. Our workshop had about 30 people so we divided into 5 or 6 teams and redesigned Business of Software conference. The feedback from this workshop was given to Mark and the BoS team.

The second workshop I attended was with Dirk Paessler on the topic of “what do people do to keep their business online”. I had hoped to attend Nemo Chou’s workshop but it was cancelled at the last minute. As such I chose Dirk’s because I thought it may be interesting even if not directly related to what I do. It turned out to be surprisingly interesting, if only because of the extraordinary lengths Dirk’s company has gone to ensure it remains online. I got quite a few business specific takeaways from this workshop.

Coming home

After conference everyone had a chance to grab some food, possibly be interviewed by the roving cameraman. He got me. I don’t think I made a very good subject. I think you’re either good at this or not. When asked a question that required a thoughtful answer I should have paused and thought. But no. So a bit of a disaster on that front. I’m sure other people had better things to say to the camera than I did.

I milled around for a bit then a group of us headed off to a local restaurant for some pre-flight food. Mark Littlewood said he’d come and join us, but he took so long he met us on the way back to the hotel. Better luck next time Mark.

The photo shows (left to right) Krishna Kotecha, Patrick McKenzie, Corey Reid, Patrick Foley, Levi Kovacs, Tyler Rooney.

TODO List

My notes are littered with TODO items scrawled done as a speaker sparked something in me. On the plane home, reflecting on the conference, I found that every few minutes I’d have to write something down. In total I have about 4 pages of TODOs, 1 per line. Thats about 120 items to do or research. All directly from attending the conference. Not all of the TODO items were new to me at the conference, but the conference reinforced my pre-existing thoughts and coallesced them into an action point.

Conclusion

If I could summarise Business of Software into a few words, it would be “Incredible mind food, stuff to think about for a long time”.

Would I go again? Yes.
Am I glad its on the East Cost of America? Yes. 5 hours out is one thing. 8 hours out another altogether.

Software Update Email Notification

At present customers that have purchased our software tools receive software software update notifications via email. In addition participants in our beta software programmes also receive software update notifications via email.

Software updates are released whenever we have bug fixes we think should be released or whenever we have new functionality we wish to make public. This can result in releases on a day by day basis or no releases for weeks at a time. We never hold bug fixes or releases back for service packs. We always try to get them to our users as rapidly as possible.

For some people the constant email notifications are too much and they ask not to be notified any more. For other people they welcome the fact that we supply bug fixes and updates on a regular basis. Clearly there is no one-size-fits-all solution to email notification.

Another problem is bounced email. Sometimes valid email addresses bounce. Do we unsubscribe this email automatically or do we try it again the next time (because quite often these email addresses spring back into life)? Either way, over time we end up building a large list of dead email addresses.

Automatic Software Updates

Starting next week, we’re going to release new software versions which are capable of self-updating. These new releases will check for the availability of a new release, prompt you to ask if you are interested in the new release and if you are, login to our server, download the software, install the software and new license keys and then restart the software.

Software Maintenance

In addition to the ability to keep the software up to date it will also be possible to update the software maintenance from within the software update package. As such you will always know when the software updates are about to expire and when you need to renew your software maintenance.

When you purchase your software tools from us we always provide you with at least one year of software updates as part of the purchase. Up until now we have never enforced that. We have provided software updates for periods much longer than one year for some customers. With this new functionality we will continue to provide one year of software updates but we will now enforce that period from January 15 2012.

As such if you’ve purchased since a year of January 15 2011 your software maintenance will continue for a year from the purchase date. If you purchased before January 15 2011 your software maintenance will need renewing on January 15 2012. Two examples should demonstrate this:

The reason for this change is because there is a cost to us to provide the software updates and we can no longer provide these for free. We always intended to charge for software updates but for various reasons never got around to do it. Thus some of you, our customers, have had a very extended period of software updates without a maintenance fee.

As of the next software update, the only way to receive updates will be via the self-updating software updater. We will not be sending out software update emails after the next update.

For beta test participants, the maintenance expiry date will be adjusted as the beta test progresses. There will be no maintenance fee for beta test participants.

How does the self-updater work?

We’ve added two menu items to the Tools menu in all full product and beta versions of the tools. These options allow you to edit the schedule when the tool will check for software updates and also to force a check for software updates.

In order to accommodate different working styles we’ve provided a variety of different update options so that the disruption to a given software developer’s workflow is minimized.

The software update schedule can be set to check for updates every day, every week, monthly or not at all. This check is performed when the software is first started on a given day. This means that people running multiple day tests (say doing regression testing on a large test suite) will not be interrupted by a software update prompt. We think that given how the tools are used they are typically not kept open for extended lengths of time and will typically be started when needed. As such checking once during startup is a suitable event to check for software updates.

The date of the most recent check is displayed on the schedule dialog.

If you wish to force a software update just choose “Check for software updates…” on the menu.

When a software update is available the user will be prompted with a confirmation dialog providing the choices to download and install the software, to ignore the download until later or to ignore the download completely.

Options for editing the update schedule or purchasing additional software maintenance are also provided.

If the user chooses to ignore the download they will be prompted about this download (or a subsequent download) at the next software update interval (the next day, next week, or next month).

If the user chooses to skip this download they will only be prompted to download if a new software version becomes available for download. Should the user change their mind they can always choose to force a check for updates using the menu “Check for software updates…”.

If the user chooses to download and install the software, the tool contacts the server and logs in using the user supplied credentials (provided when you purchase the software or join a beta test). If no login credentials have been supplied the user is prompted for the login credentials.

Once logged into the server the software downloads the software with progress shown on a download progress dialog.

When the software is downloaded successfully the tool will close and the software will be installed. Finally the tool is restarted so that work can continue with the tool.

Expired Software Maintenance

Software maintenance has an expiry date. The software continues to work but the ability to receive software updates ceases at this date. When software maintenance has expired a software maintenance expiry dialog is displayed. The user of the software has the opportunity to purchase additional software maintenance to continue receiving software updates.

Software Maintenance Pricing

Given that I’ve discussed purchasing maintenance I should just briefly cover maintenance pricing otherwise you may decide to spend time scouring the website for maintenance pricing. To save you that effort here is the brief summary.

The software maintenance fee is 25% of the listed purchase price on our website. This excludes any special offer pricing. This means that if you received a volume discount when purchasing the software the maintenance fee automatically includes the same volume discount pricing.

The easiest way to purchase this will be by clicking the appropriate purchase buttons on the software. They will log you into the website, choose the correct product and correct number of users and price etc, all automatically. And when the purchase is complete the correct account and expiry details will be updated. Much easier than trying to do this any other way.

Conclusion

This new method of providing software updates will be less intrusive (much less email) and more customizable (you can choose the update schedule). We hope you will find this a useful improvement to our current software update schedule.

Be sure to look out for the next software update email from us. You’ll need to download that software update to get the version of the software that can self-update as described in this article. If you wish to continue receiving software updates you will need the next version of our software tools.

We welcome your thoughts and comments on these changes.

Since the dawn of electronic computing we’ve had valves disrupted by transistors, mainframes disrupted by minicomputers, mincomputers disrupted by workstations, workstations disrupted by PCs and PCs disrupted by notebooks and netbooks. The latest entrant is the tablet computer.

Tablets were initially a failure, mainly due to desktop operating systems being forced to do a job they were ill suited to do. However the Apple iPad changed all that. A new way of considering how to use a tablet. This has spawned a lot of imitators, mainly based on Android. Microsoft will also be entering the fray with Windows 8 and the Metro UI. Microsoft is making the reverse mistake though – forcing its tablet UI on its desktop users. So it may succeed in the tablet space and then fail in the desktop space. We shall see.

Disruptive or Complementary?

Having set the scene the next question is are tablets going to be disruptive to PCs or complementary? Some people seem to think its a straight fight between PCs and tablets – that tablets are going to disrupt PCs and ultimately replace them. Even Professor Clayton Christensen, author of many books on industrial disruption thinks this is going to happen. His latest tweet on the subject “The value of theory: you know that iPads will cannibalize PCs long before the data tells you it’s happening http://bit.ly/nlSq2l #disruption”.

I’ve read most of Professor Christensen’s books on disruptive innovation theory. I think the case is well argued and I find the books fascinating and engaging. I think I do understand the theory correctly. There is always room to improve my understanding.

But I don’t agree that just because iPad shipments exceed PC shipments its the end for the PC. Not even a long way into the future. When I say PC I’m talking not just Windows, but Macs and Linux boxes etc. Anything that sits on your desktop, under the desk, or a portable computer like a laptop, notebook or netbook.

I think tablets are in the main, complementary to PCs. By complementary I mean that they are providing opportunities in places where a PC is not practical or appropriate. I do think tablets will erode some consumer use of PCs. I do not think tablets will replace PCs in the business world.

Tablets

Tablets are great for passive consumption of data. For example, viewing movies, reading email and writing occasional replies, viewing websites, playing games, viewing 2D and 3D models. Touch screen UIs excel at the consumption of content.

Tablets will almost certainly gain traction in areas where you want to view business data. RedGate software’s SQLMonitor is a great example of this.

Tablets will almost certainly gain traction in areas where you need to update the status of items but do not need to type extensive reports. A scenario for this would be in hospitals. Keyboards are a haven for bugs as they are hard to clean effectively. Tablets are smooth and easy to clean. Tablet touch screens are perfect for this type of work – well designed user interfaces will minimise the need to type and make a tablet usable in this situation.

The above two scenarios are not really tablet vs PC scenarios. They are complementary. The tablet is enabling a business activity that the PC either did badly, or could not do at all. For the SQLMonitor example, the tablet is doing the job better than the PC, is is more convenient. But this is a data consumption task (as opposed to content creation). In the hospital example, no one carries a laptop to the bed of the person they are seeing and then checks off their health and medication as they do their rounds. But I can easily see that happening with a tablet. That is, the tablet is serving an underserved or nonserved market.

But all that said, tablets are not good for any large scale content creation activity. Examples are word processing, accounting, creative work, video editing, audio editing, 3D CAD creation, writing software. All these activities are typically done by professionals with two or more large screen monitors with multiple windows open at once, referencing data in one window, cutting and pasting into another, sometimes having specialised external interaction devices (drawing tablets, styluses, trackballs, joysticks etc). For businesses that need computers the above describes the majority of those computing activities.

The 3D CAD creation item is an interesting one. I know some folks at SolidWorks Corporation. When the iPad came out they created a viewer for it. Have they moved to put SolidWorks on the iPad? No. Its a $4000/seat software product. People use it on powerful workstations with multiple screens with large resolutions. You just cannot replicate this experience on a tablet.

The other interesting point is software creation. When Apple introduced the Macbook, Macbook Pro and Macbook Air computers web developers and creatives very quickly switched to these computers to do their work. Have these people moved to the iPad or any other tablet to do their creative work? If a tablet was suitable for content creation these people would have switched already and be trying to prove it can be done.

PCs

However when it comes to content creation the PC is the place where that will continue to happen.

There are several reasons why PCs will continue to dominate in this area:

• PCs are designed to be used for content creation. The ability to have multiple windows open, multi-task, source data from one application easily into another application, these are key to being efficient at the job in hand. Tablets just can’t do this. I can’t see this being fixed on a tablet.
• Multiple screens, with physical screen sizes up to 30″ and pixel counts exceeding 2500 across. Even if you could get a 30″ tablet with 2560×1600 resolution, you wouldn’t be able to lift it and it would be too heavy and too unweildy to rest in your lap when you sit on the sofa.
• Egonomics. The ergonomics of using a tablet are such that for occasional use sitting on the sofa, lying in bed, etc, they do you no harm. I can speak from my own painful experience with RSI that for extended periods of working a tablet will give rise to all manner of unpleasant ailments. I can see all the problems with poor posture and static loading that did so much damage to me, those problems are all there with the tablet. And those problems will always be there because that is a function of the form factor of a tablet.

In summary at large screen sizes, where tablets could in theory start to compete against a PC, the tablet becomes unweildy, impractical and in ergonomic terms, bad for you. If with advances in materials science – let us say if carbon fibre manufacture became cost effective and e-ink is the future – then the weight element of a large tablet would go away. But you’re still left with the physical size limits of a tablet that is 23″ (or more!) to deal with. I’m writing this on a 23″ screen and I could not imagine trying to sit with this on my lap.

You can improve the touch screen typing of a tablet, but the on screen keyboard will always obscure your work. At present there appears to be no solution to the multi-window aspect of computing that has been so successful on workstations and desktop computers for the last 30 years. Tablets have one window (or with Windows 8 Metro, possibly two) at a time. As you can see in the comments sections of the 4 blogs posts dedicated to the Metro UI and Search on the MSDN blogs, people that work with multiple large screens and many windows absolutely hate being forced to work with one window at a time. I confess that I am one of the many detractors of Microsoft’s new user interface work – it seriously degrades what they are doing.

Conclusion

It is inevitable that for some tasks PCs have been used for (mainly consuming information) tablets may well replace them as the best item “hired to do the job”. But I think there is quite a large section of jobs for which the tablet can never successfully compete against the PC – jobs which require multiple screens, large screens, overlapping windows/displays and specialised data entry devices.

Simply making the tablet larger is not a solution due to physical size constraints. Adding lots of external devices to the tablet (using say bluetooth) kind of defeats the point because then you can only use the tablet in one place – it no longer has the very attribute that makes it attractive (its single object portability) – you may as well use a desktop PC in that situation, it would be better suited to the task.

I think tablets are complementary to PCs. I think tablets are doing a job PCs have never been able to do well. I think PCs do a job that tablets will never be able to do well.

I think this quote from I-DotNET written in the MSDN blog comments Windows 8 Search best describes a tablet.

Touch-screen UIs are not the next generation of UI the way that GUIs and the mouse replaced the command line. Instead, what we’re seeing here is the creation of a brand new category of device, a device that is used differently for different purposes and often by different people. The touch screen UI is simply the UI best suited for this category. No more. No less.

Some background

I’ve been a member of MSDN since late 1994 when I first heard about MSJ magazine and then heard about MSDN. I’ve worked with Microsoft technologies for the vast majority of the time since then and pretty much exclusively since 1998. I’ve hated the backwards steps the Start menu took from Windows XP to Windows Vista/7 but the Windows 8 process – well that is such a change that I think this will debut so badly that this will be worse than the reception Vista received.

The Vista machines we purchased we got rid of. We have Vista as virtual machines only. We do like Windows 7 though. That works.

So far, despite repeated trials of Windows 8, all I can say is that it is awful. It is not productive, not for how we work. I don’t care how good it is at touch or how well it does web related home-consumer tasks. None of that helps me be productive in my day job. That is what counts. It is, more importantly, also what counts for my customers.

I want Windows 8 to be a success. That is why I am pushing back so hard against the Windows 8 start screen.

MSDN Blog articles

The first article Evolving the Start menu explains what they did and why they did it. It received a lot of negative criticism. They followed up with a second article Designing the Start screen which completely ignored all the criticism and tried to steamroller the Start Screen as superb. This duly received a lot of further criticism.

There is now a third article Reflecting your comments on the Start screen which is full of information, insights and analysis on how they came to arrive at the Start screen and why they think the Start menu should go away. The problem is the arguments are not convincing.

Menus are inefficient

The first argument is that the Start menu is inefficient. That it requires dextrous control of the mouse to find and select an item (this is true) and that it is slow to do so (also, reasonably true).

Therefore they introduce the start screen which is a 2 dimensional grid of tiles that you can easily find with your mouse etc. The problem is, this is not true. They boast that on screens of 1900 x 1080 resolution you can have 80 tiles.

Whooppee! Er No.

I have a screen of 1900 x 1200 and it has 72 icons on the desktop. Can I easily find the icon I want to launch a program? Yes, sometimes. But most of the time I have to scan the whole thing to find the one I want. And I organised that group of icons. It is not efficient. Sometimes despite knowing what I want is in my list of 72 icons I can’t find it and I give up and go and find it from the Search menu anyway.

And Microsoft want all of us to work this way in future. Yikes!

And of couse when you can’t find it you then have to use the new Search functionality. Which I’ll tell you about now…

Search

The old Start menu had a search function on it. In Windows 2000 and Windows XP this was really efficient – you could tell it where to search, what to look for in a document all before starting the search. No time wasted.

In Windows Vista and Windows 7 this was awful, very inefficient. You had to start a search you knew would fail, then bring up the search widget, choose custom and flail around in that awful user interface then get the search (with no progress indicator showing which directory was getting searched – we had that in W2K and XP).

The new Windows 8 search function – there isn’t one. Wait, there is. Just its invisible. Which is why I didn’t know it exists. Its that discoverable that an MSDN member of 17 years could not find it.

Yes, I know I know, I must be an old fart, but seriously. If I can’t find it can my parents, can my girlfriend, can the people working in the Vetinary surgery down the road? No they can’t.

To use search in Windows 8 you have to switch to the start screen and then type. That’s right type into nothing, just type. Apparently this nonesense is inspired from mobile phones. Thats great. Except it isn’t. I’m happy with that metaphor on a phone. But I want my PC to behave like a PC. What is efficient for one device is not efficient for another. If that were true we’d control aircraft the same way we control submarines. Unsurprisingly we don’t.

Furthermore when you switch to the Start menu to make your search you lose the context of your work – so god help you if were hoping to read some text from a website or a document to type into the search widget. How efficient is that? They just made you add an extra step – you now have to copy and paste the text from the website or document. What? The text isn’t copy and pastable? Oh dear, no you’ve got to copy the text off the document onto some paper, switch to the Start screen and then type what you’ve written on paper into the invisible search widget.

Sound exaggerated? Perhaps. But I can see this happening. Especially with less au-fait users like the aforementioned people at the Vetinary surgery (I am actually thinking of some people I know – good with animals, not so with computers – just things to use, on the Desktop!).

But I don’t know what I’m looking for

You don’t know what you’re looking for? So how will you know when you find it? Well, I can kind of remember its name, but not really, but I’ll know it when I see it.

Its like being in a library in the philosophy section and you’re not sure what you’re looking for then all of a sudden you hit the section of Thoreau books and out pops the one you’re looking for. How could I have forgotten its name? Silly me.

Well indeed. And its the same with programs. Often I can’t remember who wrote it (so I can’t select by Vendor) or what its exact name is. My developer machine has 94 menus on the Programs section and most of those have submenus with between 5 and 10 items on. Some have more and some have more submenus. That is a lot of program names to rememeber. Unsurprisingly I don’t rememeber them. I have better things to devote my memory to. But I can browse those menus relatively easily and with reasonable speed.

The main reason I can do that, browse between 450 and 900 items is because each menu only exposes the data under it when I look at it. If I had to look at all 450-900 items at once it would impossible. Most of the items I never look at the submenus, I just have to read the main menu entry and then move on or occasionally check the contents.

It is an efficient compromise between having to use search to search for all executables and then dig through the ridiculous number of results (very slow) and the other extreme where I have to remember them all.

The problem with Windows 8 is that there is no Start menu to browse. I have to use search to find what I want. How can I find what I want when I don’t know its name? Answers on a postcard please (or leave them in the comments section).

Live Updates

A few of the comments in support of Metro in the MSDN blog comments indicate that the poster of these comments thinks that people with views like mine are dinosaurs that can’t see the value of having updating live tiles. What a limited and narrow view.

Such live tiles were previewed in Vista with the gadgets on the screen. Sure they are useful. I haven’t said they are not useful. I have said I don’t wish to work that way. These are different concerns just as some people wish to drive manual cars and others don’t want that chore so they choose an automatic car. In fact that is not a bad analogy, Metro would be the automatic car (less control) and Start Menu users would be driving a manual car (more control).

I have no need for an email tile keeping me up to date with my email. Why? Because I work with 2 computers and three screens. One computer is dedicated to handling email and browsing the web. The other one is for development work. The email machine has an email browser open all the time. Even if I had one machine I’d have the email client open all the time. An email tile is a waste of CPU time for me.

Also, if you know anything about productivity the last thing you want is a screenful of animated tiles doing their thing in your peripheral vision. Nice eye candy for the easily impressed. Boring annoyance for those of us that want to get stuff done.

Ubuntu One

Linux? Who cares about Linux? Why suddenly talk about Linux?

Well they’ve already done this particular experiment for you. The most recent release of Ubuntu comes with the Ubuntu One interface as the default. This is a user interface that makes you access everything via tiles (admittedly more restricted than Metro) and forces you to work with single screen applications.

I first tried it on my netbook. My initial thoughts were that it was good. Web browser and email clients come up full screen (all 800×600 of it!) and I could browse the web OK.

Then a few weeks later I thought I’d install Ruby On Rails on it and take a toy project away with me for a bit of tinkering while on a break. What a disaster. Totally impossible to get anything done in these single whole-screen environments. I spent a good deal of my time in the task switcher moving one window to the front, finding another, then moving that to the front and so on.

That installation of Ubuntu got replaced with the standard Ubuntu classic and all future installations are setup deliberately to exlude Ubuntu One. If you read around the web you’ll find lots of power users also hate Ubuntu One. Just like the power users complaining on the MSDN blog about Metro. You’re taking control (and thus productivity) away from your best customers.

Multi-Screen

The Windows 8 Start Screen covers all your screens. Not user friendly at all. Completely stops any context. As far as I am concerned losing even one whole screen is way too much, especially when you consider how efficient and non-context losing the start menu is.

If the start screen could be encompassed in a resizable window so you could move it whereever you want, or minimize it out of the way that would be useful. This in addition of course, to actually having a proper functioning start menu.

Multi-Tasking

Many complaints have been made about the inability to kill tasks in the Metro interface (all you can do is suspend them). Also the lack of support for multi-tasking windows is a real productivity killer.

These complaints remain un-addressed by the Windows 8 developer team.

No Compromise

The Windows 8 developer team seem completely unconcerned that those of us that want to use their PC to do work do not wish to work in a fashion that is dictated by the needs and desires of those whose only use for a PC is to consume the web/youtube/facebook/email on their tablet or gaming PC.

Both groups of people can be accomodated.

• Business users. Leave our Windows Desktop alone and give us the Start menu we know and love.
• Home users. By all means give them the tablet UI you have designed Metro for.

Why can’t this be a configurable option? A powerful Start menu option for folks like myself and the Metro interface for people that think search is a useful replacement for the Start menu.

User Experience

The user experience that I have had with Windows 8 Developer Preview has been extremely poor. Open source operating systems like Haiku give you a better experience out of the box.

Dog Food

I really do wonder if the Windows 8 Developer team is using Windows 8 to develop Windows 8. And I mean everyone, the management team, everyone that has to use office, powerpoint, email, MS Project, all the development team, including people using WinDbg and Visual Studio. I can’t believe they are because the loss in productivity would be huge.

I have to conclude the only people eating the Windows 8 dog food are the home consumer testing group that want a tablet/phone/home-user user interface.

Productivity

I hope that having read this far you realise that the problem with Windows 8 Start Screen is not the start screen itself. It is the drop in productivity and the horrible context switch from Desktop to Start Screen (which itself is a productivity issue) that are the issues. We know what is productive for us. And, although you think you know best for us Microsoft, you don’t.

I’ve already experienced Windows Vista/7 search and hate it. I don’t want to have to use Windows 8 search even more than I already have to use Windows 7 search.

Keep search as what it is good for and allow me to browse for my files, productively, using the Start menu.

Windows 8 #fail

I hope that when Windows 8 finally debuts people can look back at this article and think “Thank God, it didn’t happen, Windows 8 is still productive”.

Otherwise we’ll all be walking around in T-Shirts with the slogan “Windows 8 #fail”.