Justin Burtch's Blog

At the end of the day today, a couple of us were talking about the nature of infinity. So I decided to google ∞ (U+221e). Here are the results:

Compare that to a slightly more common number:

Maybe I spent too much time in the SQLCLR world today, but the result counts just made me laugh.

Over on Chris's blog, he laments about the abundance of CodeProject and Experts Exchange hits he gets from search queries and he typically ignores them. If you want to automate this removal, you can remove sites from results in search engines:

In Live Search:

http://search.msn.com/results.aspx?q=TEST+-site%3Acodeproject.com+-site%3Aexperts-exchange.com

In Google:

http://www.google.com/search?q=TEST+-site%3Acodeproject.com+-site%3Aexperts-exchange.com

You can setup a search provider in IE with these defaults at: http://www.microsoft.com/windows/ie/searchguide/en-en/default.mspx. Just fill in the form on that page and avoid sifting though the results in the future. On a side note, it looks like this form generates some special XML that ends up creating a key in the registry at:

HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\SearchScopes\{SOME_GUID}

Jeff Atwood's post is top notch as always. Developers write too much code. Between gold-plating and feeling they need to write a solution from soup-to-nuts, we end up with just too much stuff to support.

The software industry needs to take a lesson from the art world and realize that a painting does not have to be a solid block of busy colors. Music has both notes and rests. Of course there are exceptions in these mediums as are there exceptions in software, but by and large, most environments could be improved be removing code.

Somebody once told me that every piece of software has at least one bug and at least one superfluous line of code. By that reasoning, the simplest application is a crashing one liner.

Outlook, you don't have to go home, but you can't stay here.

When Outlook 2007 came out, I decided to start reading blogs in Outlook, but I have noticed that some feeds just would not update.  No matter how many times I did a send/receive, no updates. Finally, I just got fed up with Outlook and downloaded RSS Bandit. In the past I have used SharpReader and Newsgator, both of which I loved, but since I'm in the market I decided to check out RSS Bandit.

I wanted to like Outlook's RSS capabilities. I was willing to overlook how it butchered posts that contained code. I was willing to overlook how the views didn't sort the way I wanted, no matter how many times I changed the sort order. But missing content is something I won't live with.

Ironically, after I exported the OPML and started removing feeds from both Outlook and the IE Feed Store, Outlook suddenly started refreshing some of these stagnant feeds. Very popular blogs that hadn't been updated in Outlook in months suddenly had 50 new posts ready for my viewing.

Maybe Outlook RSS V2...

I want to thank all the attendees who came to the CAB and ObjectBuilder talks I gave at the recent Reston code camp and CMAP code camp. I have posted the slides and demos at my file dumping grounds at http://jburtch.brinkster.net/samples/.

Eventually I will have a more comprehensive samples site online, but right now this simple launching page will have to do.

So, when I first looked at WPF (then Avalon) back in early 2005 we had just had another presidential election, so based on current events I created a sample. Basically, I converted individual SVG maps to Avalon polygons and carefully arranged them by hand and did the data binding.

Well last week, I decided to upgrade the sample to WPF 1.0 and the results can be seen here. If you think the XBAP app is cool, please download the code from here.

Some of the interesting things of the application are:

• Custom themed buttons for all the states.
• Styles based on state name
• Styled polygons within a style based on political party
• Data Binding for election results.
• Individual State data binding.
• Automatic updates of all data binding via INotifyPropertyChanged.

As an example of the individual state themes, the unthemed application looks like this:

When styled, each button's style is set to "{Binding Converter={StaticResource StateStyleConverter}}" and that takes each state name and converts it to a well known style for that state defined in the app.xaml file. The results are:

Another interesting piece is the semi-transparent flyout on the right hand side. It is done by animating the X value of a RenderTransform for the flyout. While the rest of the application was hand coded or converted from SVG via tools on the web and some custom code, I created the flyout and animation with Expression Blend. I then disconnected the animation and decided to call the animations manually. I'm sure I could have done this in all XAML, but was fine with the 8 lines of code to toggle between the expanded and collapsed state.

I hope people enjoy looking at this as much as I enjoyed creating it.

I've been using CAB heavily on a project and I thought I would share some code I wrote to overcome the way UI Elements get inserted into ToolStripMenus and ToolStrips.

Before I get started, lets set up a trivial scenario that is somewhat contrived for my purposes. I created a new SmartClient application project in VS2005.  This set up the shell and some infrastructure assemblies to support the Smart Client Software Factory tooling. My goal was to create a menu & toolbar structure that looked like this:

Pretty simple but here is the catch:

I want the Exit menu to be design-time included in the File menu in the Shell, but the rest of the toolbar and menu items to come from two business modules. I called these modules: EvenModule and OddModule. The sole purpose of these two projects is to create menu items (EvenModule created even numbered items and OddModule create odd numbered items.)

So with this in mind, I first exposed the File menu as a UIExtensionSite by providing an accessor in the ShellForm:

internal ToolStripItemCollection FileMenu
{
    get { return fileToolStripMenuItem.DropDownItems; }
}

And registered it in the ShellApplication (the bold line below):

protected override void AfterShellCreated()
{
    base.AfterShellCreated();

    RootWorkItem.UIExtensionSites.RegisterSite(UIExtensionSiteNames.MainMenu, this.Shell.MainMenuStrip);
    RootWorkItem.UIExtensionSites.RegisterSite(UIExtensionSiteNames.MainStatus, this.Shell.MainStatusStrip);
    RootWorkItem.UIExtensionSites.RegisterSite(UIExtensionSiteNames.MainToolbar, this.Shell.MainToolbarStrip);
    RootWorkItem.UIExtensionSites.RegisterSite(UIExtensionSiteNames.FileMenu, this.Shell.FileMenu);
}

I also created a new constant named FileMenu in Infrastructure.Interface.Constants.UIExtensionSiteNames, but I won't show the code for that.

With the File menu now exposed, I created the two business modules EvenModule and OddModule. They are similar enough that I will only show EvenModule's ModuleController. This was the only code I added to either module.

namespace NewbrookSolutions.EvenModule
{
    public class ModuleController : WorkItemController
    {
        public override void Run()
        {
            ExtendMenu();
            ExtendToolStrip();
        }

        private void ExtendMenu()
        {
            if (!WorkItem.UIExtensionSites.Contains(UIExtensionSiteNames.FileMenu))
                return;

            UIExtensionSite site = WorkItem.UIExtensionSites[UIExtensionSiteNames.FileMenu];
            for (int i = 2; i < 10; i += 2)
                AddNumberedMenuItem(site, i);
        }

        private void ExtendToolStrip()
        {
            if (!WorkItem.UIExtensionSites.Contains(UIExtensionSiteNames.MainToolbar))
                return;

            UIExtensionSite site = WorkItem.UIExtensionSites[UIExtensionSiteNames.MainToolbar];
            for (int i = 2; i < 6; i += 2)
                AddNumberedButton(site, i);
        }

        private void AddNumberedMenuItem(UIExtensionSite site, int itemId
        {
            ToolStripMenuItem item = new ToolStripMenuItem("Item " + itemId.ToString());
            site.Add(item);
        }

        private void AddNumberedButton(UIExtensionSite site, int itemId)
        {
            ToolStripButton item = new ToolStripButton("Item " + itemId.ToString());
            item.DisplayStyle = ToolStripItemDisplayStyle.Text;
            site.Add(item);
        }
    }
}

As you can tell each module extends the FileMenu and MainToolStrip by adding buttons and menu items. When you run the application at this point you get the following result (depending on the order of definitions of the EvenModule and OddModule in the ProfileCatalog.xml file in the shell project.)

So this wasn't the result I wanted. Because I registered the File Menu's drop down list, each item is added to the end of the menu. This can easily be overcome by using this approach. That will put the Exit menu at the bottom but will still leave the numbered items in order of insertion rather than in the order my "requirements" stipulated.

To go further it helps to know how items are merged into UIExtensionSites. When you call the UIExtensionSite.Add method, it delegates the addition to an Adapter class that gets passed in when you registered the site. The adapter class gets selected by asking the registered service IUIElementAdapterFactoryCatalog to find an appropriate adapter factory. Adapter factories are registered by calling IUIElementAdapterFactoryCatalog.RegisterFactory. Each factory implements IUIElementAdapterFactory. This interface defines two methods. The Supports method returns a boolean regarding if the factory can create an adapter for the passed in object. In the case of the common Menu and Toolbar items, these are instances of type: ToolStrip, ToolStripItem, and ToolStripItemCollection. The second method defined in IUIElementAdapterFactoryCatalog is called GetAdapter and returns an Adapter appropriate for the same item. When UIExtensionSites are registered, the catalog finds the first adapter factory that supports the object and gets the adapter from the factory and passes it into a newly created UIExtensionSite.

So back to our UIExtensionSite.Add call; the Add method calls the adapter's Add method to insert the item into the site. As David's post shows the insertion point depends on what you registered.

If you registered a ToolStripItemCollection (like I showed originally,) items get added to the end of the collection.
If you registered a ToolStripItem (like David showed,) items get added immediately after the registered item.
If you registered a ToolStrip, items get added to the end of the Toolstrip's items.

The Solution

So first we need to decide why something should appear before another item. I decided to use the MergeIndex that is defined for all ToolStripItems. I first changed the MergeIndex for the Exit MenuItem to 1000 (arbitrarily big number). Then I altered the insertion code in EvenModule and OddModule to set the MergeIndex to itemId before adding to the UIExtensionSite.

I thought of several approaches. First I could create my own IUIElementAdapterFactory and register it before the built in Microsoft.Practices.CompositeUI.WinForms.UIElements.ToolStripUIAdapterFactory. In theory, the catalog would find my implementation first. Unfortunely, the catalog only provides a mechanism to add factories to the end of the list and no mechanism to remove factories.

The actual registration of the ToolStripUIAdapterFactory happens in Microsoft.Practices.CompositeUI.WinForms.WindowsFormsApplication.AfterShellCreated. I could have just omited the call to base.AfterShellCreated() in ShellApplication, but there could be a lot of potention make up code I would have to write to take care of the other actions base.AfterShellCreated() would perform. Instead I decided to take action after base.AfterShellCreated had run its course. ShellApplication's new AfterShellCreated looks like this:

protected override void AfterShellCreated()
{
    base.AfterShellCreated();

    IUIElementAdapterFactoryCatalog oldCatalog = RootWorkItem.Services.Get<IUIElementAdapterFactoryCatalog>();
    RootWorkItem.Services.Remove<IUIElementAdapterFactoryCatalog>();

    IUIElementAdapterFactoryCatalog newCatalog = RootWorkItem.Services.AddNew(oldCatalog.GetType(), typeof(IUIElementAdapterFactoryCatalog)) as IUIElementAdapterFactoryCatalog;
    newCatalog.RegisterFactory(new MergingToolStripUIAdapterFactory());
    foreach (IUIElementAdapterFactory factory in oldCatalog.Factories)
    {
        if (!(factory is ToolStripUIAdapterFactory))
            newCatalog.RegisterFactory(factory);
    }

    RootWorkItem.UIExtensionSites.RegisterSite(UIExtensionSiteNames.MainMenu, this.Shell.MainMenuStrip);
    RootWorkItem.UIExtensionSites.RegisterSite(UIExtensionSiteNames.MainStatus, this.Shell.MainStatusStrip);
    RootWorkItem.UIExtensionSites.RegisterSite(UIExtensionSiteNames.MainToolbar, this.Shell.MainToolbarStrip);
    RootWorkItem.UIExtensionSites.RegisterSite(UIExtensionSiteNames.FileMenu, this.Shell.FileMenu);
}

Basically, I remove out the old catalog, re-register a new catalog service (of the same type). Add my new AdapterFactory (MergingToolStripUIAdapterFactory). Then I loop through the old catalog and copy all the factories that weren't the one I didn't like. Technically, I didn't need to remove out the ToolStripUIAdapterFactory because mine will get hit first. Also, by default ToolStripUIAdapterFactory will be the only factory in the collection, but just to be safe, I do the copy.

Now onto MergingToolStripUIAdapterFactory. Basically, I copied the ToolStripUIAdapterFactory code and changed the type of adapters returned from GetAdapter:

namespace NewbrookSolutions.Infrastructure.Interface.UIElements
{
    public class MergingToolStripUIAdapterFactory : IUIElementAdapterFactory
    {
        public IUIElementAdapter GetAdapter(object uiElement)
        {
            if (uiElement is ToolStrip)
                return new MergingToolStripItemCollectionUIAdapter(((ToolStrip)uiElement).Items);

            if (uiElement is ToolStripItem)
                return new MergingToolStripItemOwnerCollectionUIAdapter((ToolStripItem)uiElement);

            if (uiElement is ToolStripItemCollection)
                return new MergingToolStripItemCollectionUIAdapter((ToolStripItemCollection)uiElement);

            throw new ArgumentException("uiElement");
        }

        public bool Supports(object uiElement)
        {
            return (uiElement is ToolStrip) || (uiElement is ToolStripItem) || (uiElement is ToolStripItemCollection);
        }
    }
}

The built-in adapters in the CompositeUI.WinForms projects are good, I just didn't like how where they insert. Fortunately, both ToolStripItemCollectionUIAdapter and ToolStripOwnerCollectionUIAdapter have a virtual method called GetInsertingIndex. Thus, my two classes just derive from the built in classes and overide GetInsertingIndex.

namespace NewbrookSolutions.Infrastructure.Interface.UIElements
{
    public class MergingToolStripItemCollectionUIAdapter : ToolStripItemCollectionUIAdapter
    {
        public MergingToolStripItemCollectionUIAdapter(ToolStripItemCollection collection)
            : base(collection)
        {
        }

        protected override int GetInsertingIndex(object uiElement)
        {
            ToolStripItem uiItem = (ToolStripItem)uiElement;
            ToolStripItemCollection collection = this.InternalCollection;

            for (int i = 0; i < collection.Count; i++)
            {
                if (collection[i].MergeIndex > uiItem.MergeIndex)
                    return i;
            }
            return collection.Count;
        }
    }

    public class MergingToolStripItemOwnerCollectionUIAdapter : ToolStripItemOwnerCollectionUIAdapter
    {
        public MergingToolStripItemOwnerCollectionUIAdapter(ToolStripItem item)
            : base(item)
        {
        }

        protected override int GetInsertingIndex(object uiElement)
        {
            ToolStripItem uiItem = (ToolStripItem)uiElement;
            int startingPosition = base.GetInsertingIndex(uiElement);
            ToolStripItemCollection collection = this.InternalCollection;
            for (int i = startingPosition; i < collection.Count; i++)
            {
                if (collection[i].MergeIndex > uiItem.MergeIndex)
                    return i;
            }
            return collection.Count;
        }
    }
}

So these two adapter will loop over the collection of items comparing MergeIndex properties until it finds the right merge spot. With this new method the merging behavior is:

If you registered a ToolStripItemCollection, items get added in MergeIndex order.
If you registered a ToolStripItem, items get added in MergeIndex order after the registered item.
If you registered a ToolStrip, items get added in MergeIndex order.

Hope this helps some other people out there and keep enjoying CAB!

I know a bunch of people have not been too enthusiastic about the unit testing features built into VSTS. Some people have become infatuated to many of the features of mbUnit. They are cool. But I like VSTS because of the built in code coverage capabilities and the integration with TFS.

While working on my current project, I got to thinking about some of these missing features and sought out to fill in a couple of gaps.  The result of a couple of nights of hacking and watching football is my VSTS framework. With it, you can create attributes to annotate test methods and somewhat extend the built in tools.

The source is here.

One caveat I must mention. Your test classes must derive from Newbrook.VSTS.UnitTestFramework.UnitTestBase. The derived class must also not provide methods annotated with [TestInitialize] or [TestCleanup]. UnitTestBase provides virtual OnInitialize and OnCleanup methods to get the same functionality, but took over those attributes to hook into the test infrastructure.

Some of the attributes I created were:

1. Rollback. Yes...inspired by Roy, I created a Rollback attribute that wraps the annotated test in a System.Transaction that always gets rolled back. Usage

[TestMethod]
[Rollback]
public void PerformSomeDatabaseTests()
{
    //Make some databasebase calls...
}

2. RequiresFileFromResource. This is an interpretation of Chris Smith's idea. Basically, when you need some files for a test, just embed the file as a resource in the test assembly and then reference it by name like:

[TestMethod]
[RequiresFileFromResource("SampleTests.Properties.Resource", "Icon1", "MyIcon.ico")]
[RequiresFileFromResource("SampleTests.Properties.Resources", "Image1", "MyImage.bmp")]
public void PerformSomeTestOnMyIconAndMyImage()
{
}

or

[TestMethod]
[RequiresFileFromResource(null, "SampleTests.ResourceFile.htm", "ResourceFile.htm")]
public void PerformSomeTestOnResourceFile_HTM()
{
}

The first method shows two things. First off, you can have multiple RequiresFileFromResource attributes on a single test method. Secondly, this is how you would copy off a resource from the Resources mechanism in VS 2005.

The second method shows how you would copy a file that is in the project that has the Build Action set to Embedded Resource.

3. TimedTest. This attribute will cause a test to fail if the test takes longer than the timespan specified.

[TestMethod]
[TimedTest("00:00:05")]
public void ThisTestWillFail()
{
    Thread.Sleep(new Timespan(0, 0, 6));
}

4. EnvironmentVariable. This attribute will alter an EnvironmentVariable for the scope of the annotated test.

[TestMethod]
[EnvironmentVariable("PATH", "%PATH%;E:\\")]
[EnvironmentVariable("MyTest", "Some Value")]
public void PerformEnvironmentVariableTests()
{
}

5. ParameterizedDataMethod. This is a complex attribute that needs to be used in conjuction with the DataSource attribute in VSTS. Let me setup the scenario. First off, I include a testfile.csv file in my project and add a setting in the .testrunconfig file to copy that file to the testdirectory (kind of hacky, but very handy.) My testfile.csv looks like:

Column1,Column2,Column3
Hello,-123,12/3/2006
World,42,12/31/2006

Then create a test like:

[TestMethod]
[DataSource("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=.;Extended Properties=\"text;HDR=Yes;FMT=Delimited\"", "testfile.csv")]
[ParameterizedDataMethodAttribute("RealTestMethod6")]
public void TestMethod6() { }

//This method gets called when TestMethod6 is called!!!
public void RealTestMethod6(string column1, int column2, DateTime column3)
{
}

In this scenario RealTestMethod6 gets called twice with the typed variables in the columns of the csv file.

<sidebar>
I haven't seen a whole lot of talk on the DataSource attribute. I love it. I use it alot for some black box testing of methods. I will typically use the first couple columns to pass parameters into the test. Then next column is my expected result and I include one additional column for ExpectedException. If you have 1 test and it is a DataSource test and it has 5 DataRows, then you will see a total of 6 tests pass/fail.
</sidebar>

Send me a line if this is beneficial or if you have some feedback or enhancements. If pepole like it and want to work with it, I'll stick it in CodePlex.

Currently downloading:

• Office Professional 2007
• Office Visio Professional 2007
• Office Project Professional 2007
• Office OneNote 2007
• Office InfoPath 2007
• Office Groove 2007

I suspect Vista will be up there next weekend.

Features that didn't make the cut (from shell: revealed)

Looks like it will be available on the Connect program the week of 25/9.

See: https://connect.microsoft.com/VisualStudio/content.aspx?ContentID=3311.

A great post from the word team regarding the easy creation of professional documents (style not substance): http://blogs.msdn.com/microsoft_office_word/archive/2006/09/18/761200.aspx.

I have found Word 2007 to be the most stable of the big office apps I use (Outlook, Excel, and Word) I has rarely crashed on me (a statement I can definitely not say about Outlook and Excel during Beta 2) and it has so many cool new usability features. I banged out an official Newbrook company template in just a couple of hours that had much of the stylistic appeal in the above link.

I was reading this post and it got me thinking about Microsoft's ever changing organization structure and how in an ideal world it could be as simple as pair programming. Imagine if two organizations could join together to meet a common goal and then part ways. There are some complications that need to be overcomed before this could ever happen including:

• Identifying organizational teaming partners
• Creating ego-free decision-making hierarchy of new organization
• Minimizing costs associated with such re-orgs (moving costs, HR overhead, etc.)

Microsoft is in a unique position because of its size. It affords them the opportunity to reform and invent based without cross-corporation  concerns. If any two orgs partner in this manner, the biggest hurdle is ownership of the resulting creations.

I would love to see Microsoft operate in the following hypothetical manner:

<hypothetical>

Mary is a PM on the Visual Studio web page designer team and is a voracious blog reader (including internal blogs.) While reading an internal post, she sees that the IE team is working towards full CSS compliance. Not being an expert in CSS, but familiar with the community enough to realize that no tools are great at creating CSS-based web sites (let alone an Microsoft tools that create ASP.NET web sites,) she sends a note to John, the CSS PM on the IE team, and they decide to meet. At the meeting they decide that there would be benefit from forming a new agile team to focus on creating a great CSS editor for VS. Of course before they can create the team, they check with their organizations to verify that this team can be formed and that the organizations are willing to free up resources for this cause.

Assuming all goes well, a small team of 5 is formed under Mary from 2 people from the original VS org and 3 people from the original IE org. The team then sets out on achieving its goals and integrating its results back into the VS products. John remains a stakeholder in the team and regularly checks up to make sure the IE team and new CSS Designer team understand the goals and directions of each other.

After a few months, the CSS designer team has produced a tool worthy of inclusion into the VS team and folds the product into the VS build and release cycle. At this point, the formation of a separate team in re-evaluated and it is determined that until the first version ships in Orcas, there is still value in having this separate team.

Once Orcas ships, the team decides that it is better to collapse the team back into VS. At this point, the team members can rejoin either team (or move off to some other product team). In addition to coming together to create something, the team also learned how the other organization branch operates and can maybe use that information to improve their original orgs. During the collaboration, the IE members learned that the dev tools team utilizes some code to help regression test the rendering of HTML views so when they rejoin the org, they let the IE test team know that this tool exists and provided some real benefit during the process.  The same collaboration process is then repeated by testers from the IE and VS teams.

</hypothetical>

Clearly collaboration happens at Microsoft. Without it, the DOJ wouldn't have been up in arms and the tooling for developers would be much more incomplete. What I would love to see is a deeper collaboration beyond meetings and tech exchanges. Ego-free team creation to come together for the larger company and community goals...

I spent some time playing around with OnFolio recently. I'm not exactly sure how Onfolio is branded, but it magically appeared on my MSN Search toolbar in IE 7 and so I started working with it.

I'm really impressed with the ability to collect bits of info into one source. As an example I recently was shopping for a next monitor.  I new I wanted a LCD and I knew it had to be ≥ 19". Now normally, I would have done a quick search and gone to CNET, then gone to a site like pricewatch and selected a place to buy the monitor.  And this was basically how I still worked, but instead of opening up dozens of IE Windows or even tabs; I just copied out snippets from pages and basically did my research. By using the flags I marked favorable reviews. I could have also added different folders based on monitor performance type (video, resolution, color, etc.) but I didn't have that much data and honestly, there aren't that many good but still inexpensive monitors. Overall, I thought it was a pretty good and intuitive tool to do my simple research project.

Later that day, I had to write some code to enumerate Active Directory pulling users and groups.  I knew roughly what I was looking for, but pulling code snippets, KB articles, and forum posts into one space helped me track my options very effectively.

Now not everything was great. Here is my wish list:

• Collections are client based files, so you can't do collections across machines.  I tried using FolderShare to sync my "My Collections" directory, but when I make a change on one machine, FolderShare on the other machine starts shrieking that th file is in use. Even when I closed down the OnFolio sidebar and even closed the collection, the file would not copy. This feature would also be useful for collaborative collection.
• The feeds feature is OK, but I would like to see a server based solution where I could add feeds, read them on one machine, have them marked as read on another machine.  Even if the sync does not happen, I would like to be able to put on a feed that get updated frequently and have a server pull the posts and push down the results when I turn on my machine. On the plus side, I really like the rendering of the Newspaper view.
• Copied files (as opposed to linked files) are opened readonly. Further investigation would need to occur to find out if this blanket statement is universally true, but it seems to be the case the Excel files. In my monitor research, I wanted to have a spreadsheet for some pricing comparisons. My intention was to embed it and as I found pricing info, make changes to the file. But all saves would fail because Excel only had a read-only copy of the file.  Links to files didn't have this issue, but links have other issues.
• Linked files don't copy when you send a collection to someone, and they certainly didn't copy when I tried my Foldershare hack. Now if I mapped the containing folder in FolderShare, maybe that would work, but probably not worth the pain. I could see there being a logical differentiation between links and embedded files, but when you send it to someone either the link should be gone or disabled or the file should be transfered.

Downloading now...only 14 hours to go...

• 120 / minute
• 7200 / hour
• 14976000 / year (40 hours/week, 52 weeks/year, no vacation)

• Fast
• Power
• Max
• Total
• Super
• Smart

I have been involved in multiple projects that have used several of these words.  All products were ripe for for Nelson-esque mocking ("Smell ya' later".)

Obviously this is by no means a complete list, but just thought I would put in my two cents. If I can save just one product name, then my job is done.

And I can't wait until someone calls it the Power Microsoft Shell...