Windows IA (Information Architecture)

One of my key projects over the last six months was to figure out an Information Architecture (IA) for the Microsoft Windows platform.  This post is a behind the scenes look at how I went about figuring out a simple IA for the Windows platform. 

You can think of an IA simply as how you structure, organize, and share the information for a particular domain.  In general, an IA is used for Web sites, because you’re thinking through the user experiences and user interaction patterns, as well as how to showcase key information in a consumable way.

It’s like a test-first platform strategy. You can test yourself against the customer’s tests for success.

The real secret is this -- you can use IAs to evaluate a platform, shape a platform, test a platform, or create guidance for a platform.  How do I know?  I’ve used this approach very successfully for each of the key platform stories I’ve worked on:  Security, Performance, Architecture, Team Foundation Server, WCF, etc.  You can browse some of the competitive studies.

The Why
The key driver for this was pretty simple.  We needed a simple lens for looking at our Windows platform, from a prescriptive guidance perspective.  By creating a shared lens, we could look at the Windows platform space in a simpler way, rationalize our body of knowledge, and evaluate existing content, as well as identify new opportunities.

Another key driver was simplicity.  It wasn’t about going off into a black box and come back with a taxonomy.  Instead, it was create a simple language or way of looking at the Windows platform to create a shared map of the space.

The Approach
I left like a fish out of water, but one thing that helps me is I don’t ever expect to have the right answers.  Instead, I expect to ask the right questions, and find the people that do.  My super skill is framing things out and making sense of things and hacking through complexity.

In this case, I followed my proven approach of collecting customer scenarios and organizing them into buckets.  I reached out to experts across our Microsoft Developer Support, our Microsoft Consulting Services, Microsoft DPE, product teams, community experts, industry experts, and customers that I’ve worked with of all company shapes and sizes.

Before you organize the rocks … gather the rocks.

Simple Windows IA Frame
This is a high-level view of the map:

Since my role was not be the Windows expert, I could focus on simplicity.  I could be a champion for the customer and focus on a simple map.  I wanted a map that was simple, but effective as a lens at the macro level and the micro level.  At the macro-level, we can look at the architectures and the application types and application scenarios, and even hot spots.  At the micro-level, we could look at the topics, APIs and features.

Expanded Windows IA Frame
Here’s a look at fleshing out the frame.  The beauty is that it was extensible and made it very easy to prioritize items within the frame – to show the simple and show the complete as needed:

Finding Hot Spots
A Hot Spot is a bucket.  It’s not a taxonomy exercise.  It has to be relevant.To test for a good Hot Spot is that it’s actionable.  In other words, it can organize principles, patterns, anti-patterns.

To find the key hot spots, I first gathered collections of customer scenarios to find themes.  Microsoft Developer Support was especially handy for finding the customer scenarios.  My friend Dan Ruder was the hero here and helped round up scenarios from his team.  His team has the bird’s-eye view of all the issues our developer customers see.

For example, here are some of the scenarios they see for the User Interface hot spot:

• How to deliver excellent user experience through UI design
• How to automate a UI
• How to design the look and feel to match Windows/Office (i.e. updated UI design guidelines)
• How to use the Theme Engine
• How to use Common Controls
• How and when to use notification icons, other UI/shell features
• How to design an application which has multiple threads
• How to avoid locking up UI threads using a background thread
• How to use a background thread for a specific task and communicate with it
• How background threads can update the UI
• How to use hooks (low-level vs. raw input, keyboard, cbt, mouse) or other technique
• How to create proper shell extensions

Improving the IA
An IA is always a work in progress.  It’s a durable, evolvable backdrop for looking at a space.  As the space changes, your lens changes.  That’s why it’s important to keep your map lightweight and flexible.

There are many ways to improve an IA once you have a strawman:

• Create IAs for your big customer segments.   One way to make an IA incredibly valuable is to specialize it around personas or particular customer segments.  Then you can speak the lingo and make things more specific and relevant to that audience.
• Specialize an IA around a view point.  For example, you can optimize around a security lens, or a performance lens, or a manageability lens, etc.
• Get community feedback.  Sharing your IA with the community is a quick way to find the holes you missed, or points of view you didn’t consider.  The trick is to map the input back into context, and rationalize it against the rest of your feedback and input.

Once you have a baseline IA, it’s easy to build on top of it or carve out for specific focuses or create variations that address specific segments.

One thing I can say about IAs if you’re bent on being right, you’re bound to be wrong.  The best IA is a shared understanding of the space.  It’s a map built from various perspectives.  Multiple perspectives are a must.  The trick is to synthesize the input and make a useful map, where the sum of the whole is more than the parts.

However, the worst IA is one that’s design by committee or where you don’t have an opinion.  The secret is having an opinion, and being OK with being wrong, learning and improving.  When you have no opinion, you don’t know what good looks like and you can’t synthesize the input.