If you see yourself in any of these, I’ll e-mail you what I have for no charge. I won’t do any processing on them, other than what I already have, however.

Gallery

I kissed Google goodbye more than a year ago and haven’t looked back. I think once people start using Bing, they’re going to do the same.

Answer Suggestions for IE8

IE8 is awesome, so go get it. Live Search has these things called Instant Answers where it can respond with succinct answers to your question, rather than just web pages that may have the answer. Good examples are weather and numeric conversions—you just want to know the answers, not necessarily follow links to find it.

You get normal search suggestions of course, but the cool thing is that the display of the instant answers is built right into IE8. You can type into the search box and have the answers returned right in the drop down as you type. Here are some samples:

Weather: Solve math equations:

There are a whole lot more kinds of answers. Maybe someday I’ll detail them.

Live Search Suggestions for Firefox

Firefox users haven’t been left out either. While there isn’t a full instant answers integration, Firefox does support search suggestions. You can download the plugin from the Firefox plugin directory.

Live Search for Windows Mobile

This is something I think really needs more publicity. I have a Samsung Saga i770, which I love. One of the first things I put on it was Live Search Mobile.

First of all, this thing has had speech recognition built-in since way before Google’s similar tools.

It can easily find directions, gas prices, movies, traffics, maps, local businesses (by categories), and general web info. I use this app all the time.

There is custom software you can install for both Windows Mobile and Blackberry. It will work on the web for any other mobile phone that can get on the Internet.

And, by the way, it supports auto-suggest as well.

On your phone, you can go to wls.live.com to get it.

Related links:

• Instant Answers in your IE8 Search box [Live Search blog]
• Live Search autosuggestions come to Firefox [Live Search blog]
• Live Search Mobile site

From everything I’ve read, people who have suffered through the WPF learning curve have this to say, more or less:

yeah, it was really tough going for a few months. But now I can create awesome apps in a fraction of the time it would take with older technologies.

So with that in mind, I really do want to learn WPF. I have a number of C# references, weighty tomes that bend my shelves, but the main book I use is Programming WPFby Chris Sells and Ian Griffiths. I really like this book—it goes in deep. However, I realized that reading through it cover to cover and doing all the sample apps wasn’t going to work—it gets boring, no matter how good the book is. So here is my recommendation on how to learn WPF (and it probably applies to any programming technology):

1. Start reading the book, do the code, type stuff in, copy it, tweak it. Do this for as long as you can.
2. Once step 1 becomes boring, STOP. It is not productive to force yourself through the whole thing like this.
3. Find a sample project in your target technology. I used Family.Show. There are plenty out there.
4. Think of a project YOU find interesting that would be good in [WPF|other]. Start doing this. Even if you don’t know where to start at all.
5. While getting started, every step will be a challenge. Figure it out step-by-step, going back to the book and online resources.

You might be tempted to skip steps 1-2. I think this is a bad idea. You need at least some foundational understanding. Only when you can’t take it any more and you’re in danger of quitting, move on.

This has worked well for me in learning WPF. I decided to implement a game (if it ever gets into a polished state, I’ll share it).

Don’t underestimate the challenges in step 4, though. I had to think about how to even start, going back to the book numerous times, reading large sections. I looked up articles online about patterns and WPF, user controls, and more. Many seemingly-small steps in just displaying windows took hours to figure out. Figuring out data binding (really figuring it out in the context of my app) took hours. The point of doing your own project isn’t because it’s easier than following the book—it’s because it’s fun and you have more motivation to learn.

• Instead of a critical section, InterlockedIncrement/Decrement is used.
• The sample driver program now demos using multiple threads using the CpuUsage class to show thread safety.

Download the C++ and C# projects that accompany this article.

Just to make it clear, there is no API called GetProcessCpuPercentage(). To find out the percentage, we can use some other, real APIs and do some calculations. Before getting to the equation and code, let’s discuss the different types of time available.

There are four types of time:

1. Wall time – The actual, real-world progression of time as measured by you on your watch.
2. Kernel time – The amount of time spent in kernel mode (protected, high-order mode of operation)
3. User time – the amount of time spent in user-mode (often by the process itself)
4. Idle time – nothing going on at all

Kernel, User, and Idle sum to total time, which is approximately wall-time.

Each process spends some time in kernel mode and some time in user mode. We just need to compare the time spent by a process to the time spent by all processes on the computer, since the last time we made such a measurement. It is important to note that we do NOT take into account the idle time.

Thus, the equation is

There are two APIs that are useful:

• GetProcessTimes – Get times for a specific process
• GetSystemTimes – Get total times for the entire system (all CPUs)

The times reported are absolute, so what we are actually interested is in the difference between the current times and those from a previous run.

Armed with this information, we can calculate the CPU usage for the current process (or any arbitrary process, for that matter).

Let’s do it first in C++ to demonstrate usage of the APIs.

CPU Usage Percentage in C++

Here’s the header file:

   1: #pragma once

   2: #include <windows.h>

   3:  

   4: class CpuUsage

   5: {

   6: public:

   7:     CpuUsage(void);

   8:     

   9:     short  GetUsage();

  10: private:

  11:     ULONGLONG SubtractTimes(const FILETIME& ftA, const FILETIME& ftB);

  12:     bool EnoughTimePassed();

  13:     inline bool IsFirstRun() const { return (m_dwLastRun == 0); }

  14:     

  15:     //system total times

  16:     FILETIME m_ftPrevSysKernel;

  17:     FILETIME m_ftPrevSysUser;

  18:  

  19:     //process times

  20:     FILETIME m_ftPrevProcKernel;

  21:     FILETIME m_ftPrevProcUser;

  22:  

  23:     short m_nCpuUsage;

  24:     ULONGLONG m_dwLastRun;

  25:     

  26:     volatile LONG m_lRunCount;

  27: };

The GetUsage() method is where the work occurs. The other methods are to help in the calculations. The critical section run count enables the code to be called in a multi-threaded environment without problems. I also prevent the code from being called more often than every 250ms. Here is the complete implementation:

   1: #include "StdAfx.h"

   2: #include <windows.h>

   3: #include "CpuUsage.h"

   4:  

   5: CpuUsage::CpuUsage(void)

   6: :m_nCpuUsage(-1)

   7: ,m_dwLastRun(0)

   8: ,m_lRunCount(0)

   9: {

  10:     ZeroMemory(&m_ftPrevSysKernel, sizeof(FILETIME));

  11:     ZeroMemory(&m_ftPrevSysUser, sizeof(FILETIME));

  12:  

  13:     ZeroMemory(&m_ftPrevProcKernel, sizeof(FILETIME));

  14:     ZeroMemory(&m_ftPrevProcUser, sizeof(FILETIME));

  15:  

  16: }

  17:  

  18:  

  19: /**********************************************

  20: * CpuUsage::GetUsage

  21: * returns the percent of the CPU that this process

  22: * has used since the last time the method was called.

  23: * If there is not enough information, -1 is returned.

  24: * If the method is recalled to quickly, the previous value

  25: * is returned.

  26: ***********************************************/

  27: short CpuUsage::GetUsage()

  28: {

  29:     //create a local copy to protect against race conditions in setting the 

  30:     //member variable

  31:     short nCpuCopy = m_nCpuUsage;

  32:     if (::InterlockedIncrement(&m_lRunCount) == 1)

  33:     {

  34:         /*

  35:         If this is called too often, the measurement itself will greatly 

  36:         affect the results.

  37:         */

  38:  

  39:         if (!EnoughTimePassed())

  40:         {

  41:             ::InterlockedDecrement(&m_lRunCount);

  42:             return nCpuCopy;

  43:         }

  44:  

  45:         FILETIME ftSysIdle, ftSysKernel, ftSysUser;

  46:         FILETIME ftProcCreation, ftProcExit, ftProcKernel, ftProcUser;

  47:  

  48:         if (!GetSystemTimes(&ftSysIdle, &ftSysKernel, &ftSysUser) ||

  49:             !GetProcessTimes(GetCurrentProcess(), &ftProcCreation, 

  50:                 &ftProcExit, &ftProcKernel, &ftProcUser))

  51:         {

  52:             ::InterlockedDecrement(&m_lRunCount);

  53:             return nCpuCopy;

  54:         }

  55:  

  56:         if (!IsFirstRun())

  57:         {

  58:             /*

  59:             CPU usage is calculated by getting the total amount of time 

  60:             the system has operated since the last measurement 

  61:             (made up of kernel + user) and the total

  62:             amount of time the process has run (kernel + user).

  63:             */

  64:             ULONGLONG ftSysKernelDiff = 

  65:                 SubtractTimes(ftSysKernel, m_ftPrevSysKernel);

  66:             ULONGLONG ftSysUserDiff = 

  67:                 SubtractTimes(ftSysUser, m_ftPrevSysUser);

  68:  

  69:             ULONGLONG ftProcKernelDiff = 

  70:                 SubtractTimes(ftProcKernel, m_ftPrevProcKernel);

  71:             ULONGLONG ftProcUserDiff = 

  72:             SubtractTimes(ftProcUser, m_ftPrevProcUser);

  73:  

  74:             ULONGLONG nTotalSys =  ftSysKernelDiff + ftSysUserDiff;

  75:             ULONGLONG nTotalProc = ftProcKernelDiff + ftProcUserDiff;

  76:  

  77:             if (nTotalSys > 0)

  78:             {

  79:                 m_nCpuUsage = (short)((100.0 * nTotalProc) / nTotalSys);

  80:             }

  81:         }

  82:         

  83:         m_ftPrevSysKernel = ftSysKernel;

  84:         m_ftPrevSysUser = ftSysUser;

  85:         m_ftPrevProcKernel = ftProcKernel;

  86:         m_ftPrevProcUser = ftProcUser;

  87:         

  88:         m_dwLastRun = GetTickCount64();

  89:  

  90:         nCpuCopy = m_nCpuUsage;

  91:     }

  92:     

  93:     ::InterlockedDecrement(&m_lRunCount);

  94:  

  95:     return nCpuCopy;

  96: }

  97:  

  98: ULONGLONG CpuUsage::SubtractTimes(const FILETIME& ftA, const FILETIME& ftB)

  99: {

 100:     LARGE_INTEGER a, b;

 101:     a.LowPart = ftA.dwLowDateTime;

 102:     a.HighPart = ftA.dwHighDateTime;

 103:  

 104:     b.LowPart = ftB.dwLowDateTime;

 105:     b.HighPart = ftB.dwHighDateTime;

 106:  

 107:     return a.QuadPart - b.QuadPart;

 108: }

 109:  

 110: bool CpuUsage::EnoughTimePassed()

 111: {

 112:     const int minElapsedMS = 250;//milliseconds

 113:  

 114:     ULONGLONG dwCurrentTickCount = GetTickCount64();

 115:     return (dwCurrentTickCount - m_dwLastRun) > minElapsedMS; 

 116: }

In order to test this, here is a simple program that starts two threads that run an infinite loop, eating the processor. On a dual-core system, this process will take roughly 85-95% of the CPU. I also start two threads to access the usage object and poll the CPU usage in order to demonstrate the thread safety of the object.

   1: // CpuUsageCpp.cpp : Defines the entry point for the console application.

   2: //

   3:  

   4: #include "stdafx.h"

   5: #include <windows.h>

   6: #include "CpuUsage.h"

   7:  

   8: DWORD WINAPI EatItThreadProc(LPVOID lpParam);

   9: DWORD WINAPI WatchItThreadProc(LPVOID lpParam);

  10:  

  11: CpuUsage usage;

  12:  

  13: int _tmain(int argc, _TCHAR* argv[])

  14: {

  15:     //start threads to eat the processor

  16:     CreateThread(NULL, 0, EatItThreadProc, NULL, 0, NULL);

  17:     CreateThread(NULL, 0, EatItThreadProc, NULL, 0, NULL);

  18:  

  19:     //start threads to watch the processor (to test thread-safety)

  20:     CreateThread(NULL, 0, WatchItThreadProc, NULL, 0, NULL);

  21:     CreateThread(NULL, 0, WatchItThreadProc, NULL, 0, NULL);

  22:     

  23:     while (true)

  24:     {

  25:         Sleep(1000);

  26:     }

  27:  

  28:     return 0;

  29: }

  30:  

  31:  

  32: DWORD WINAPI WatchItThreadProc(LPVOID lpParam)

  33: {

  34:     while (true)

  35:     {

  36:         short cpuUsage = usage.GetUsage();

  37:  

  38:         printf("Thread id %d: %d%% cpu usage\n", ::GetCurrentThreadId(), cpuUsage);

  39:         Sleep(1000);

  40:     }

  41: }

  42:  

  43: DWORD WINAPI EatItThreadProc(LPVOID lpParam)

  44: {

  45:     ULONGLONG accum = 0;

  46:     while (true)

  47:     {

  48:         accum++;

  49:     }

  50:  

  51:     printf("%64d\n", accum);

  52: }

C# Version

In C#, The System.Diagnostics.Process can give us the time information for a specific process. However, we still need the Win32 API call for getting the total system times (GetSystemTimes). The Process class reports times in TimeSpans, not FILETIME, so our class is modified accordingly.

   1: using System;using System.Collections.Generic;

   2: using System.Linq;

   3: using System.Text;

   4: using System.Runtime.InteropServices;

   5: using ComTypes = System.Runtime.InteropServices.ComTypes;

   6: using System.Threading;

   7: using System.Diagnostics;

   8:  

   9: namespace CpuUsageCs

  10: {

  11:     class CpuUsage

  12:     {

  13:         [DllImport("kernel32.dll", SetLastError = true)]

  14:         static extern bool GetSystemTimes(

  15:                     out ComTypes.FILETIME lpIdleTime,

  16:                     out ComTypes.FILETIME lpKernelTime,

  17:                     out ComTypes.FILETIME lpUserTime

  18:                     );

  19:  

  20:         ComTypes.FILETIME _prevSysKernel;

  21:         ComTypes.FILETIME _prevSysUser;

  22:  

  23:         TimeSpan _prevProcTotal;

  24:         

  25:         Int16 _cpuUsage;

  26:         DateTime _lastRun;

  27:         long _runCount;

  28:  

  29:         public CpuUsage()

  30:         {

  31:             _cpuUsage = -1;

  32:             _lastRun = DateTime.MinValue;

  33:             _prevSysUser.dwHighDateTime = _prevSysUser.dwLowDateTime = 0;

  34:             _prevSysKernel.dwHighDateTime = _prevSysKernel.dwLowDateTime = 0;

  35:             _prevProcTotal = TimeSpan.MinValue;

  36:             _runCount = 0;

  37:         }

  38:  

  39:         public short GetUsage()

  40:         {

  41:             short cpuCopy = _cpuUsage;

  42:             if (Interlocked.Increment(ref _runCount) == 1)

  43:             {

  44:                 if (!EnoughTimePassed)

  45:                 {

  46:                     Interlocked.Decrement(ref _runCount);

  47:                     return cpuCopy;

  48:                 }

  49:  

  50:                 ComTypes.FILETIME sysIdle, sysKernel, sysUser;

  51:                 TimeSpan procTime;

  52:  

  53:                 Process process = Process.GetCurrentProcess();

  54:                 procTime = process.TotalProcessorTime;

  55:  

  56:                 if (!GetSystemTimes(out sysIdle, out sysKernel, out sysUser))

  57:                 {

  58:                     Interlocked.Decrement(ref _runCount);

  59:                     return cpuCopy;

  60:                 }

  61:  

  62:                 if (!IsFirstRun)

  63:                 {

  64:                     UInt64 sysKernelDiff = 

  65:                         SubtractTimes(sysKernel, _prevSysKernel);

  66:                     UInt64 sysUserDiff = 

  67:                         SubtractTimes(sysUser, _prevSysUser);

  68:  

  69:                     UInt64 sysTotal = sysKernelDiff + sysUserDiff;

  70:  

  71:                     Int64 procTotal = procTime.Ticks - _prevProcTotal.Ticks;

  72:  

  73:                     if (sysTotal > 0)

  74:                     {

  75:                         _cpuUsage = (short)((100.0 * procTotal) / sysTotal);

  76:                     }

  77:                 }

  78:  

  79:                 _prevProcTotal = procTime;

  80:                 _prevSysKernel = sysKernel;

  81:                 _prevSysUser = sysUser;

  82:  

  83:                 _lastRun = DateTime.Now;

  84:  

  85:                 cpuCopy = _cpuUsage;

  86:             }

  87:             Interlocked.Decrement(ref _runCount);

  88:  

  89:             return cpuCopy;

  90:                 

  91:         }

  92:  

  93:         private UInt64 SubtractTimes(ComTypes.FILETIME a, ComTypes.FILETIME b)

  94:         {

  95:             UInt64 aInt = 

  96:             ((UInt64)(a.dwHighDateTime << 32)) | (UInt64)a.dwLowDateTime;

  97:             UInt64 bInt = 

  98:             ((UInt64)(b.dwHighDateTime << 32)) | (UInt64)b.dwLowDateTime;

  99:  

 100:             return aInt - bInt;

 101:         }

 102:  

 103:         private bool EnoughTimePassed

 104:         {

 105:             get

 106:             {

 107:                 const int minimumElapsedMS = 250;

 108:                 TimeSpan sinceLast = DateTime.Now - _lastRun;

 109:                 return sinceLast.TotalMilliseconds > minimumElapsedMS;

 110:             }

 111:         }

 112:  

 113:         private bool IsFirstRun

 114:         {

 115:             get

 116:             {

 117:                 return (_lastRun == DateTime.MinValue);

 118:             }

 119:         }

 120:     }

 121: }

These classes can now be used wherever you need to monitor the CPU usage of a process.

Notice any improvements to be made? Leave a comment.

Download C++ and C# projects

For my current project, I needed a panel to layout controls vertically. The TableLayoutPanel can be awkward to work with, at least for what I need it to. At first glance, the FlowLayoutPanel looks it won’t work, since it produces something like this:

That’s with changing the FlowDirection to TopDown and putting AutoScroll to true.

But what I want is this:

To achieve this layout, merely set all the following properties on a FlowLayoutPanel:

• AutoScroll = True
• FlowDirection = TopDown
• WrapContents = False

et voilà, Instant stack panel.

With the new Webmaster Tools, you can now see which pages on your site are infected with malware (aka drive-by downloads). The links are clearly highlighted and disabled so that you won’t accidentally click on them.

Not only that, but you can also see what pages that your site links to are infected with malware. This is great if your site allows any user-generated content and it’s possible that some link spam has made it on.

In addition to these improvements in Webmaster Tools, the general Live Search engine is using the same malware detection to notify users of bad pages in the general search results. To see this, click on the link as if to visit it and you’ll get a pop-up instead.

If you run your own site, get signed up in Webmaster Tools and make sure you’re not contributing to the malware problem. If you do find that your site has malware on it, once you’ve removed it you can request that your site be reanalyzed.

For more info, check out these other blogs and articles:

• Live Search Webmaster Center Fall Update [Webmaster Center blog]
• Webmaster tools now sniffing for malware [Live Search blog]
• Microsoft’s Live launches malware detection service for webmasters [ZDNet blogs] (though the author incorrectly assumes that Live Search itself doesn’t offer this feature)
• Link to search results for articles about this

Here’s a brief run-down of my initial experience with it.

Installation

There is no installation file—everything is packaged into a zip. After running, I was greeted by a project selection screen, in which I created a new project and added some assemblies.

Analysis

Once you have all the assemblies you want to analyze selected, you can run the analysis, which generates both an HTML report with graphics, and an interactive report that you can use to drill down into almost any detail of your code. Indeed, it’s almost overwhelming the amount of detail present in this tool.

One graph you see almost immediately is Abstractness Vs. Instability.

This is a good high-level overview of your entire project at the assembly level. Basically, what this means is that assemblies that are too abstract and unstable are potentially useless and should be culled, while assemblies that are concrete and stable can be hard to maintain. Instability is defined in the help docs in terms of coupling (internal and external), while abstractness is the ratio of abstract types to total types in an assembly.

This is followed by the dependency graph:

After these graphics come lots of reports that dig into your code for all sorts of conditions.

For example, the first one in my report was “Quick summary of methods to refactor".” That seems pretty vague, until you learn how they determine this. All the reports in NDepend are built off of a SQL-like query language called CQL (Code Query Language). The syntax for this is extremely easy. The query and result for this report are:

With very little work on my part, I instantly have a checklist of items I need to look at to improve code quality and maintainability.

There are tons of other reports: methods that are too complex, methods that are poorly commented, have too many parameters, to many local variables, or classes with too many methods, etc. And of course, you can create your own (which I demonstrate below).

Interactive Visualization

All of these reports are put into the HTML report. But as I said, you can use the interactive visualizer to drill down further into your code.

The first thing you’re likely to see is a group of boxes looking like this:

These boxes show the relative sizes of your code from the assembly level down to the methods. Holding the mouse over a box will bring up more information about the method. You can also change the metric you’re measuring by—say to cyclomatic complexity.

Another view, perhaps the most useful of all is the CQL Queries view. In this, you can see the results from all of hundreds of code queries, as well as create your own. For instance, I can see all the types with poor cohesion in my codebase:

In this view, the CQL queries are selected in the bottom-right, and the results show up on the left. The metrics view highlights the affected methods.

Creating a query

Early in the development of my project, I named quite a few classes starting with a LB prefix. I’ve changed some of them, but I think there are still a few lying around and I want to change them as well. So I’ll create CQL query to return all the types that begin with “LB.”

   1: // <Name>Types beginning with LB</Name>

   2: WARN IF Count > 0 IN SELECT TYPES WHERE 

   3:  NameLike "LB" AND     

   4:  !IsGeneratedByCompiler AND 

   5:  !IsInFrameworkAssembly     

That’s it! You can see the results to the right. It’s ridiculously easy to create your own queries to examine nearly any aspect of your code. And that’s if the hundreds of included queries don’t do it for you. In many ways, the queries are similar to the analysis FxCop does, but I think CQL seems generally more powerful (while lacking some of the cool things FxCop has).

VS and Reflector Add-ins

NDepend has a couple of extras that enable integration of Visual Studio (2005 and 2008) and NDepend and Reflector. When you right-click on an item in VS, you will have some additional options available:

Clicking on the submenu gives you options to directly run queries in NDepend. Very cool stuff.

Summary and where to get more info

If you are at all interested in code metrics, and how good your code is behaving, how maintainable it is, you need this tool. It’s now going to be a standard part of my toolbox for evaluating the quality of my code and what parts need attention.

If you’re using NDepend for personal and non-commercial reasons, you can download it for free. It doesn’t have all the features, but it has more than enough. Professional use does require a license.

One of the things I was particularly impressed with was the amount of help content available. There are tons of tutorials for every part of the program.

I’m going to keep playing with this and I’m sure I’ll mention some more things as I discover them. For now, NDepend is very cool—it’s actually fun to play with, and it gives you good information for what to work on.

Links:

• NDepend homepage
• NDepend metrics explanation

I first saw this video at the Microsoft Company Meeting 2008, and looked for the song everywhere, but couldn’t find the Magneta Lane version. They recorded it just for Microsoft. Nevertheless, the original Ash version is great too, so get that in the meantime.

Magneta’ Lane’s MySpace page does mention the song, and maybe a release is on the way.

Update: Forgot the music video from Ash. I like it.

Half way through the training, while discussing something tangentially related to my problems, I realized the technical solution to the specific issue I was facing.

Sometimes you just need to ignore the problem for a while, and come back to it from a different angle.

The computer on the Enterprise is an interesting entity to think about. A crew member can ask it just about any question and it can give the desired answer. It doesn’t matter if the question is slightly vague, or depends on prior knowledge of the conversation. What phenomenal power! How does it work?

I can think of only two possibilities:

1. It can read their minds
2. It has been paying attention to their conversation, and thus understands the context.

Not discounting the possibility of the first scenario, I want to think about the second.

Context

How much understanding of our immediate environment is due to context? When analyzing a situation we have at our disposal our

1. Experience
2. Book knowledge
3. Logical analysis/intuition (I include them in the same since intuition could theoretically be a subconscious logical process, colored with experience—I don’t know if I believe that, but it’s not important)

Now take away experience. How would you fare when confronted with new situations (Which, by definition, are all situations)?

Most of us, I think, would understandably quail under the rigor of thought required to get through such an ordeal. If you believe otherwise, make the situation extreme—flying a plane, or leading a squad into war. No amount of knowledge or rational thought will help here—you need the benefit of hard-core training: experience–context.

Do this exercise: describe to someone what salt tastes like.

On the other hand, saying “It’s too salty.” immediately conveys exactly what you mean, based on shared context, mutual experience.

There is an enormous gap between where our computer systems are now, versus what is perhaps the holy grail of foreseeable technology, the computer on the Enterprise—an all-seeing, all-knowing, conversant entity. It’s like Wikipedia, but to a depth of knowledge unheard of on any web site today, all cross-referenced and Searchable.

Wikipedia is a decent (I won’t say great) source of much knowledge, but it’s hardly definitive, or all-encompassing. Also, it’s just facts. It’s not calculation or interpretation. It does not advise or synthesize.

In Star Trek, when  a crewmember asks questions, they can be these fact-based, context-free questions that require simple look-ups to respond with. But often, there is a series of questions, with dialogue in-between, all related to a certain topic. Each query does not contain the total information required to retrieve a response. Rather, the computer has tracked the context and maintained an accurate representation of the conversation thus far. In essence, the computer is participating in the conversation fully.

An idea of what context means is demonstrated by this simple list of questions. Just imagine giving these to a computer or search engine today. The first one is ok, but following that, not so much.

• What are the latest Hubble Telescope pictures?
• When were these taken?
• How much longer will it stay up?
• How will the next space telescope be different?
• Compare the efforts of all G7 nations to build orbiting observation platforms.

Each of those questions presupposed the previous one. The computer must keep track of this. That last one is a real doozy—it’s asking the computer to synthesize information from multiple sources into a coherent, original response. We can’t even dream of something this advanced right now, but I believe it’s coming.

On the other hand, let’s take a different direction, more personal:

• Which of my friends are having a birthday in the next month?
• What book should I read next?
• What do I need to get at the store?
• Where are my children?

Is this possible to do today? Yes, technologically speaking.

It’s not technology that will hold us back. It’s us.

Security, Privacy

Think of what it means to have a computer able to access full context to answer any query you throw at it. It has to know everything about you. To give you good food recommendations, it has to know where you’ve eaten and how you liked it. To be able to answer arbitrary questions in context, it needs to record your every conversation, parse it,  cross-reference it, and store it for later access.

In our current culture, what this means is tying together all systems. There are intimations of this happening. Every time you hear of a company providing an API to access its data, that’s a little piece of this context being hooked up. It means that the Computer now has access to your Facebook and LinkedIn data, so that when you search for “tortoise” it can see you’re a developer and a high-proportion of software developers want to actually download “TortoiseSVN”, not see pictures of reptiles. In fact, it probably means there is no such thing as Facebook (or any other social network) anymore. There is just one network filled with data.

It becomes even more intertwined. If I really want the computer to have full context of me, it should monitor what I watch on TV, what my tastes in music are, where I go, where I work, my habits, who I call, what I talk about, etc., etc., etc. It never ends.

Now, here’s the million-dollar question: who would agree to such invasive procedures, even if the benefit was enormous?

In many ways, we are agreeing to it all the time. We allow places like Amazon, Netflix, and iTunes to track all our purchases in order to give us decent recommendations (in the hope we’ll purchase more). We give up our privacy a bit when we get the grocery loyalty cards, or even credit cards. This is all tracked and correlated. In the case of recommendation systems, there is a tangible benefit for us,but the loyalty cards are less certainly valuable to us, other than lower prices (which is not an inherent benefit of those cards, just a marketing tactic). Indeed, studies have shown for just how little we humans give up our privacy.

There are a few levels of security we need to worry about. At a low level, how much do you trust Google, or Microsoft, or Apple, or Amazon with your information? Right now, a lot of us trust them with a fair amount, but nowhere near our entire life’s story. We have it neatly segmented. Part in Amazon, part in Facebook, part in Google, part in all the other companies we deal with. If mistakes are made, consequences not thought through, we have problems like all our friends seeing what we’re purchasing.

At a high level, we need to consider all of this context ending up in the wrong hands. Not just scammers and other low-lifes, but government, foreign and domestic. The potential for abuse is massive—so much so that most of us wouldn’t voluntarily agree to any of the unifying ideas in this essay in our lifetimes. We just don’t trust anybody that much.

In essence, a Star Trek-like computer would require massive amounts of “spyware” on every system in the world, all tied together in a massive database. This is possible (maybe even desired?) in a closed system like a ship, where everything is easily monitored and hierarchies of security are well-understood. In the world at large, it’s just scary.

Economy and Altruism

I believe another obstacle to this is money. The way our society works, with limited resources, we are required (?) to have some system of trade, an economy. These days, the trade is often over information, the very thing this mythical Star Trek computer depends on. Think credit reports, buying history, demographics.

What is the specific danger of businesses finding out personal information about you? Can they force you to buy something? Not likely. But they can manipulate the environment in such a way to make it more likely. They present a lie designed to sell you something you don’t need. More maliciously, they can also sell your information to more vital entities, like insurance companies, or governments. If the government is too powerful, there is no way to prevent this. Think about what happens in China.

Is the only way to have such efficient and helpful systems to do away with our current capitalistic economy? Yes and no. Such far-reaching, life-changing technologies will undoubtedly continue to be developed and become more a part of our lives than they already are. Unfortunately, the potential for abuse is enormous and will grow as we become more and more dependent on them. We have no inherent trust in the system, nor should we. Just look at the ridiculous politicking taking place over voting machines. That’s just one system, and our society can’t get it right. We have a thousand such systems, many hanging onto usefulness and security by a thread. I bet that it’s not even the exception, but the rule to have such systems. Why should we trust such things to run our lives? We shouldn’t. There are so many reasons for this: corruption, economy, politics, and motivation.

Perhaps motivation is they key. We are often motivated now by money, comfort, or some other selfish reason—reasonable or not. In the Star Trek vision of the future, we see a population depicted as motivated by a quest for knowledge and understanding. That’s why they can have all-knowing computers. They trust who created it and what it does. They know there is no political or other ulterior motive. Yes, there’s adequate security and protections against attack, but the whole starting mindset is different.

Don’t think that I’m in favor of destroying capitalism in favor of more socialistic or idealistic systems. Imposing a system of “fairness” or “equality” does nothing to further those goals and I’m not advocating any political or economic system—I’m merely stating what I think the reality must be in the future for us to make these advancements. People themselves must reform their motivations. Pushing any political system has no effect because the fundamentals of our world haven’t changed. Resources are still scarce, thus economy must still exist. If people’s intrinsic motivations are to be changed, I believe resources must be (practically) infinite.

When this happens the nature of the Internet will change as well. If the economics change and we are no longer concerned with that, and we also have an altruistic frame of mind, information that is posted on the Internet will similarly change. No longer do we have to actually care about our walled gardens—the information is just put “up there”, in the “cloud”, to use the popular term. A computer would be free to just quote the contents to the user, or recombine it with other content. It’s all just content, with a single interface to access it all.

Understanding

There’s an important issue I glossed over in the above paragraphs. That is understanding. I talked a little about this in my previous blog entry about Software Creativity and Strange Loops.

I’m excited for this future. I doubt I’ll live to see advances fully along these lines. The problems are phenomenally difficult and they’re not all technical, but it’s still exciting to think about. Those of us who can just need to do our small part to contribute towards it.

A computer that records and correlates conversations real-time must have a phenomenal ability (compared to our current technology) to not just syntactically parse the content, but also construct semantic models of it. If a computer is going to respond intelligently to you, it has to understand you. This is far beyond our current technology, but we’re moving there. In 20 years who knows where this will be. In 100, we can’t even imagine it. 400 years is nearly beyond contemplation.

The philosophy of computer understanding, and human-computer interaction specifically is incredibly interesting. I was led to think a lot about this while reading Robert Glass’s Software Creativity 2.0. This book is about the design and construction of software, but it has a deep philosophical undercurrent running throughout that kept me richly engaged. Much of the book is presented as conflicts between opposing forces:

• Discipline versus Flexibility
• Formal Methods versus Heuristics
• Optimizing versus satisficing
• Quantitative versus qualitative reasoning
• Process versus product
• Intellectual versus clerical
• Theory versus practice
• Industry versus academe
• Fun versus getting serious

Too often, neither one of these sides is “right”—they are just part of the problem (or the solution). While the book was written from the perspective of software construction, I think you can twist the intention just a little and consider them as attributes of software itself, not just how to write it, but how software must function. Most of those titles can be broken up into a dichotomy of Thinking versus Doing.

Thinking: Flexibility, Heuristics, Satisficing, Qualitative, Process, Intellectual, Theory, Academe

Doing: Discipline, Formal Methods, Optimizing, Quantitative, Product, Clerical, Practice, Industry

Computers are wonderful at the doing, not so much at the thinking. Much of thinking is synthesizing information, recognizing patterns, and highlighting the important points so that we can understand it. As humans, we have to do this or we are overwhelmed and have no comprehension. A computer has no such requirement—all information is available to it, yet it has no capability to synthesize, apply experience and perhaps (seemingly) unrelated principles to the situation. In this respect, the computer’s advantage in quantity is far outweighed by its lack of understanding. It has all the context in the world, but no way to apply it.

A good benchmark for a reasonable AI on the level I’m dreaming about is a program that can synthesize a complex set of documents (be they text, audio, or video) and produce a comprehensible summary that is not just selected excerpts from each. This functionality implies an ability to understand and comprehend on many levels. To do this will mean a much deeper understanding of the problems facing us in computer science, as represented in the list above.

You can start to think of these attributes/actions as mutually beneficial and dependent, influencing one another, recursively, being distinct (at  first), and then morphing into a spiral, both being inputs to the other. Quantitative reasoning leads to qualitative analysis which leads back to qualitative measures, etc.

It made me think of Douglas R. Hofstadter’s opus Godel, Escher, Bach: An Eternal Golden Braid. This is a fascinating book that, if you can get through it (I admit I struggled through parts), wants you to think of consciousness as the attempted resolution of a very high-order strange loop.

The Strange Loop phenomenon occurs whenever, by moving upwards (or downwards) through the levels of some hierarchical system, we unexpectedly find ourselves right back where we started.

In the book, he discusses how this pattern appears in many areas, most notably music, the works of Escher, and in philosophy, as well as consciousness.

My belief is that the explanations of “emergent” phenomena in our brains—for instance, ideas, hopes, images, analogies, and finally consciousness and free will—are based on a kind of Strange Loop, an interaction between levels in which the top level reaches back down towards the bottom level and influences it, while at the same time being itself determined by the bottom level. In other words, a self-reinforcing “resonance” between different levels… The self comes into being at the moment it has the power to reflect itself.

I can’t help but think that this idea of a strange loop, combined with Glass’s attributes of software creativity are what will lead to more intelligent computers.

But I definitely like the I’m a PC ads better. I was at the company meeting when they debuted, and they immediately sparked a rumble in the audience—a positive one.

The cool thing is you can upload your own picture or video with your “I’m a PC” acting debut.

There are some interesting ones: a guy singing in the shower, for instance. Steve Ballmer’s is worth a look.

The greatest thing about these ads, though, is that they essentially take all the wind out of the obnoxious Apple ads that have been on for years.

I think sometimes the universe decides it needs to humble you, remind you just how thin the thread is from which we all hang. Months of comparative ease and happiness demand a balance.

Yesterday, we were rebalanced. Now, I realize that our misfortunes pale in comparison the suffering that many peoples of world undergo daily, never mind the financial turmoil we’re going through at the moment.

In fact, the individual events that happened to us aren’t really all that notable—it’s the juxtaposition that is suspicious.

We were out yesterday at an event and when we tried to leave, our car did not start. The gas was low (my wife was happy to remind me that she mentioned that we should have filled up the previous night), but I didn’t really think that was it. Still, one of our newly-made friends runs home to get gas, but the nozzle is made for a lawnmower, not a car, so it doesn’t reach. Someone else goes home to get a funnel. We put 3 gallons in there—just to be certain. It still doesn’t start. First impressions are wonderful, aren’t they? (at least they don’t think I’m an idiot for running out of gas). The car eventually gets towed to a local garage (turns out it’s a bad ignition coil).

When we get home, we set up a little of the furniture we’ve gotten for our house—we decide it doesn’t look nearly so good as we thought—this is demoralizing, to say the least.

Then I foolishly put something into the dishwasher that had been covered with soap (from the move). Next time I walked into the kitchen, the floor was covered with bubbles. Fun.

To end the day, I noticed that a screw was coming out of my glasses and I take it out to try to reseat it. Oops. 90 minutes later I got it back in.

<sigh>

Today was better, though.

I’ve got some blog topics planned—it’s just been too hectic to have time to write lately. I didn’t even have a computer desk until yesterday, and it still doesn’t have a computer under it. Maybe today…

After my last day of work at GeoEye, I went to get my haircut at a nearby salon. I asked for it a little shorter. Between the time I gave this brief instruction, and the time she lifted her hands to my head, a seismic, cosmic, interrupting event took place that transformed my words into: “Kindly shave my head, I have no need of hair. Please don’t ask for confirmation.”

At least, that’s what I assume happened. Before I could say anything, an electric razor had taken quite a bit off the top. It wasn’t to the skin–thank goodness. But I was on my way to a whole new look.

It was too late to fix it, so I went with it.

The next day we flew out to Seattle to look for housing with our new realtor. I had to excuse myself for looking like a skinhead.

Of course, the next Monday I started at Microsoft and had my badge picture taken. That one will be alive for a while…

And my drivers license…

And all the pictures of my wife and I in a new location…

The team I’m working in is great. Everybody really knows their stuff and it’s fairly intimidating trying to comprehend all the knowledge (both project and organizational) that you need to drink from the fire hose. Supposedly, it takes an average of 6 months before most people feel like they’re contributing 100%. That seems like a really, really long time, given how fast things move in the Internet age. So far, I’ve mostly read code (fixed one small bug, and found another), and done online training (of which there is a LOT–you don’t have to do everything, but there’s a an awful lot there to choose from). It’s easy to start feeling caught between wanting to contribute as soon as possible and not wanting to screw up other people’s work.

I’ve also got to come up with my yearly commitments this week–a daunting task when you don’t know anything. Thankfully, my lead is a lot of help. There’s a nice big section for personal development and I’m planning on reading Scott Meyer’s Effective C++ and More Effective C++. They’ve been on my list for a while, but now I can get graded on it!

I don’t know if I’ve mentioned it explicitly before, but I’m working on the Webmaster team as part of Live Search. The Webmaster tools are the interface between web site owners and the Live search index. If you have a web site, you should definitely create an account with our tools so you can see how your site is performing.

About Live Search in general…

Over a year ago I briefly tried Live Search as my main search engine, but quickly moved back to Google. About 6 months ago (before I was contacted about the job at Microsoft, incidentally), I decided to look at Live again–HUGE improvement. I have very rarely gone back to Google since then.

There are also some really exciting new features coming for both Live and the webmaster tools, so give them a try now and again in a few months. I can also personally attest to the fact that the Live Search team takes feedback seriously. If you have any issue with your site, or the results of your query–write up a little note and send it to the feedback page, or even send me an e-mail and I can make sure it gets sent to the right people.

P.S. My blog entry about my interview experience did make the rounds and a number of people commented to me on it….weird feeling…more infamous, than famous. Lesson: Make sure you never writing something you wouldn’t mind other people reading back to you. (I don’t think I did…)

I’ve been working on a project using Visual Studio Tools for Office 2008 (VSTO) and at one point I needed to get the colors for categories in Outlook 2007. There are actually 3 colors, and they are returned as uint’s–why the .Net wrappers don’t convert to colors for you, I don’t know (to avoid linking to System.Drawing?).

The important thing is to convert them into the friendly System.Drawing.Color objects I know and love. For this task, there exists a handy ColorTranslator class. There is a FromOle method that does the exact chore you need. Here’s a sample of my code:

   1: private void GetCategoryColors()

   2: {

   3:     foreach (OutlookLib.Category category in

   4:         Application.ActiveExplorer().Session.Categories)

   5:     {

   6:         CategoryColor color = new CategoryColor(

   7:             ColorTranslator.FromOle((Int32)category.CategoryGradientTopColor),

   8:             ColorTranslator.FromOle((Int32)category.CategoryGradientBottomColor),

   9:             ColorTranslator.FromOle((Int32)category.CategoryBorderColor));

  10:         _categoryCollection[category.Name] = color;

  11:     }

  12: }