Craig McMurtry's WebLog

Skyfall

2012-11-15T21:32:26Z

I have to talk to someone about the newest James Bond film, Skyfall.
Lacking anyone I know personally who cares, I’m doing it here. Maybe there will be spoilers in what I am about
to write.

While Skyfall is
not as bad as Quantum of Solace was
and while it might be a fine action thriller, it’s not a good James Bond
movie. What’s the standard by which one
can make such an assessment? Well, I
think we can quickly agree that any of the Eon Sean Connery films set the
standard. We’d probably debate what else
belongs in that pantheon. I’d certainly
include a great many other films that I consider superior, including On her Majesty’s Secret Service, Live and Let Die, For Your Eyes Only, The
Living Daylights, Goldeneye, The World is Not Enough and Eon’s Casino Royale.

What might we distill from among those to be the requirements
for a good James Bond film? I propose
that the foremost criterion is that a good James Bond movie incorporates ideas
that are not found in other films of the era.
I found none of those in Skyfall
and by that criterion, I dismiss it as an inferior James Bond film. An excellent example of the sort of novel
idea that is entirely missing from Skyfall
is the frogman fight in Thunderball. Scuba-diving was not science fiction when the
latter film was made; anyone of moderate means could go scuba diving. The idea of having dozens of scuba-divers
battle each other underwater, though, was ingenious and, I surmise, devilishly
hard to film at the time. By contrast, a
motorcycle chase over the rooftops of Istanbul is not conceptually
brilliant. In fact, it feels like
something that was done at least as well in a Jason Bourne movie; the second
one, if I remember correctly.

A reasonable counter-proposition might be that although the
Eon Casino Royale is generally
accepted as one of the finest Bond films, it actually doesn’t have any of those
sorts of ideas. That might be true,
although Le Chiffre’s predicament arguably qualifies and so does Vespa’s betrayal,
which is the reason for the Bond’s progressive mental deterioration and
misogyny in the novels. And what
certainly qualifies as a remarkable idea was the whole notion of making a Bond
film with brutally-realistic hand-to-hand combat and showing the agent at the
outset of his career. Unfortunately, it
turns out that’s not enough of an idea to power Quantum of Solace and Skyfall
as well.

Something else that was remarkable in the original Bond
movies was a particular character trait of Bond himself. He loved to kill his opponents. To do so was to triumph, and he relished
that. Look at the smirk on Connery’s
face when he kills Professor Dent in Dr.
No. There had been anti-heroes in
film before James Bond, but never one who was presented quite so heroically
while being that brutal. Daniel Craig
incorporates something of that attitude into his performance, but it’s a different
nuance. In his performance, the response
to killing is more one that conveys surprise at being the one that
survived. That’s interesting, but not
interesting enough. Craig’s Bond is also
written as being too much of a hero. At
the beginning of Skyfall, for
example, he hesitates over a wounded colleague.
That plot point is relevant with respect to M’s behavior in that scene,
and M’s behavior is what Skyfall is
all about. But a compassionate James
Bond is not a memorable or interesting as the refined brute. The brute was even present in Roger Moore’s
version. After bedding a woman in Live and Let Die, he kills her and as he’s
about to do that, she protests: ”You wouldn’t kill me after what we’ve just
done!” “Well, I certainly wouldn’t do it
before,” Bond replies as he pulls the trigger.

Now Eon’s Casino
Royale was the James Bond film that most closely followed the plot of the
original Fleming novel, other than From
Russia with Love and, of course, Thunderball,
where the novel was written for the screen.
After seeing that film, which I consider to be one of the very finest of
the series, I thought it would be a wonderful idea for Eon to now proceed with
a series of movies that filmed the books, using their new approach of very
realistic violence rather than the science fiction and even comic action that
had become a hallmark of the franchise.

Did you know that, with Skyfall,
they’re essentially doing just that? Yes,
Skyfall is a more faithful movie
version of the novel, The Man with the
Golden Gun than the Roger Moore film with title.

Now, let’s say that one decided to go back to the original
texts and bring them to the screen using the rich yet muted palate of Casino Royale. Would one naturally start with the novel that
was least well-received, having been published posthumously from an early Ian
Fleming draft? Even if one might dismiss
the quality of the novel given that one would be adapting it anyway, lifting
only the essential plot elements, might not the earlier Golden Gun film given one pause?
As bad as Quantum of Solace
was and as bad as License to Kill was,
I propose that we can quickly agree that The
Man with the Golden Gun is certainly the worst James Bond movie.

But there it is. Skyfall is a filmed representation of
Fleming’s novel, The Man with the Golden
Gun. In the beginning of the book,
Bond is presumed dead, just as he is in Skyfall. When he returns, his fitness for duty is
questioned in both treatments. In the
book, a former double-o agent returns from a disappearance and attempts to kill
M. Bond is that agent in the novel,
whereas in the film, it’s Mr. Silver. In
the book, Bond must stop the killing of British agents, which is precisely his
mission in Skyfall. The assassin in the novel is identified by
his unique choice of weapon and ammunition.
An assassin in Skyfall is
identified by his unique bullets. In the
book, Bond catches up with the principal villain on an island he’s taken over,
which is exactly the setting in which Bond finds Mr. Silver in the movie. Just in case aficionados might have missed
these hints, some additional ones are provided by which Skyfall references the earlier Golden
Gun film. In both movies, Bond
visits Macau and proceeds from there to an island in the South China Sea. And in the climax of both films, someone dies
because although they shoot first, they’re shooting at a mirror image of their nemesis.

I can only suppose that, if one wants to reboot the franchise
by going back to the original texts then it might have been considered less
riskly to do so with one of the least well-known plots than it would have been
to redo From Russia with Love, for
example. Still, I would have thought Golden Gun would have been toxic
material to reference. Could it possibly
have come up in the pitch meeting?
Surely the Eon folk have an encyclopedic knowledge of the pantheon and recognized
the intention.

For all of my disappointment with Skyfall, I wouldn’t hesitate to say that it’s a fine action
thriller. In particular, Bond’s scene
with Séverine in the bar is extremely well
written and masterfully acted. Watching
that scene made me expect that I would end up feeling delighted by the
movie. Then a subway train crashed
through a ceiling and I knew it is was hopeless and just wanted it to be
over.

A fine action thriller doesn’t
nearly qualify as a good James Bond film; otherwise, License to Kill would not be close to the bottom of every Bond film’s
list. All the good James Bond films rely
on novel ideas for their effect, and Skyfall
doesn’t have any of those.

Jon Duckett's "HTML and CSS: Design and Build Websites:" Go from CSS zero to hero in an evening

2012-10-03T19:07:28Z

Whenever I've developed Web applications, which I used to do all the time and now do only periodically, I've never had the luxury of receving HTML and CSS from the designer: only an image of the layout. I expect that's not entirely uncommon, that the work of rendering the designs with HTML and CSS is sometimes the work of the developer along with the coding, and sometimes the work of the designer.

When I learned the craft originally, I'd found "Instant HTML Programmer's Reference: HTML 4.0 Edition," by Alex Homer, Chris Ullman and Steve Wright, to be an excellent resource. I still have a very, very battered copy of it always handy.

However, now that I've found myself writing a stylesheet again after several years of not having to do that, I wanted to refresh myself, and carted home several books from Barnes and Noble that looked useful. The one that looked best in the store turned out to be a fantastic choice. It's Jon Duckett's "HTML & CSS: Design and Build Websites," published by Wiley.

Why is it excellent? Well, the author doesn't just identify all of the CSS properties and values with examples of the effects--which a lot of texts on the subject do. Duckett does more. He identifies the fundamentals, such as block and inline elements, which are implicit in the technology, and layers his account of each property and value on that foundation. Then he tops it off by presenting state-of-the-art advice and useful techniques.

As other reviewers of the book have mentioned, the thing also looks gorgeous. Duckett himself is credited as a designer along with Emme Stone.

I was going to post this review where I thought it would have the most effect, on Amazon.com, but there I was surpised to find that the book is only available through the marketplace and not sold directly by the world's biggest bookseller. That's unfortunate. I think everyone that has anything to do with getting pages up on the Web would benefit from owning Jon Duckett's book.

Displaying a downloaded icon

2011-12-31T22:23:09Z

Let's say that you want your Microsoft Foundation Classes (MFC) application to display an icon that it has downloaded, rather in the way that Internet Explorer displays icons on its tabs.

The first step is to download the remote icon to a local file. Here is a function for doing that:

void WebResource::Download()

{

if(!(this->uniqueIdentifier))

{

::AfxThrowNotSupportedException();

}

CFile fileLocal(this->fileName,CFile::modeWrite|CFile::modeCreate);

const UINT BufferSize = Constants::BufferSizeInBytesDownload;

char* buffer = new char[BufferSize];

if(!(buffer))

{

THROW(new CMemoryException());

}

CInternetSession session;

CStdioFile* fileRemote = session.OpenURL(this->GetLocator());

if(!(fileRemote))

{

Exception::Throw(IDS_ERROR_DOWNLOAD_TARGET_TEMPLATE,this->GetLocator());

}

UINT downloaded = 0;

BOOL result = TRUE;

try

{

::ZeroMemory(buffer,BufferSize);

downloaded = fileRemote->Read(buffer,BufferSize);

if(downloaded <= 0)

{

break;

}

fileLocal.Write(buffer,downloaded);

if(downloaded < BufferSize)

{

break;

}

while(TRUE);

}

catch(...)

{

result = FALSE;

}

if(fileRemote)

{

delete fileRemote;

};

if(buffer)

{

delete [] buffer;

}

if(!(result))

{

Exception::Throw(IDS_ERROR_DOWNLOAD_TEMPLATE,this->GetLocator());

}

The next step is to load the icon from the local file. Here is a function that accomplishes that task:

HICON WebResource::GetIcon()

{

if(!(this->icon))

{

if(!(::PathFileExistsW(this->fileName)))

{

this->Download();

}

this->icon = (HICON)::LoadImage(

NULL,

this->fileName,

IMAGE_ICON,

Constants::HeightWidthIcon, //16

Constants::HeightWidthIcon,

LR_CREATEDIBSECTION|LR_LOADMAP3DCOLORS|LR_LOADFROMFILE|LR_SHARED|LR_VGACOLOR);

}

return this->icon;

}

Note that the desired height and width of the icon are specified. If the .ico file happens to include icons of different dimensions, then specifying the desired height and width will ensure that the preferred one will be loaded.

The last step is to paint the icon. Here is the implementation of OnPaint that accomplishes that:

void Tab::OnPaint()

{

CPaintDC deviceContext(this);

CRect area;

this->GetClientRect(&area);

this->displayBehavior->DisplayTab(&deviceContext,&area);

WebResource* iconResource = webResource->GetIconResource();

if(iconResource)

{

this->PaintIcon(&deviceContext,iconResource);

}

deviceContext.SelectObject(this->font);

deviceContext.SetBkMode(TRANSPARENT);

deviceContext.SetTextColor(this->colorText);

deviceContext.DrawText(this->webResource->GetLocator(),&this->areaLabel,Tab::StyleText);

}

void Tab::PaintIcon(CDC* deviceContext, WebResource* iconResource)

{

if(!(iconResource))

{

return;

}

try

{

if(!(this->icon))

{

this->icon = new Icon();

if(!(this->icon))

{

return;

}

if(!(this->icon->Create(deviceContext, this->iconHandle,this->colorBackground)))

{

this->InvalidateIcon();

return;

}

if(this->icon)

{

CDC* memoryContext = this->icon->GetDeviceContext();

if(memoryContext)

{

deviceContext->BitBlt(this->areaIcon.left,this->areaIcon.top,Constants::HeightWidthIcon,Constants::HeightWidthIcon,memoryContext,0,0,SRCCOPY);

}

catch(...)

{

return;

}

Tab::Icon::Icon()

{

this->InvalidateDeviceContext();

}

Tab::Icon::~Icon()

{

this->DeleteDeviceContext();

}

BOOL Tab::Icon::Create(CDC* targetContext, HICON iconHandle, COLORREF backgroundColor)

{

BOOL result = FALSE;

this->InvalidateDeviceContext();

this->backgroundBrush.CreateSolidBrush(backgroundColor);

while(!(result))

{

CBitmap iconBitmap;

if(!(iconBitmap.CreateCompatibleBitmap(targetContext,Constants::HeightWidthIcon,Constants::HeightWidthIcon)))

{

break;

}

this->deviceContext = new CDC();

this->deviceContext->CreateCompatibleDC(targetContext);

CBitmap* originalBitmap = this->deviceContext->SelectObject(&iconBitmap);

HGDIOBJ originalBrush = this->deviceContext->SelectObject(this->backgroundBrush);

if(!(this->deviceContext->PatBlt(0, 0, Constants::HeightWidthIcon, Constants::HeightWidthIcon,PATCOPY)))

{

break;

}

if(!(this->deviceContext->DrawState(

CPoint(0,0),

CSize(Constants::HeightWidthIcon,Constants::HeightWidthIcon),

iconHandle,

DST_ICON|DSS_NORMAL,

(HBRUSH)NULL)))

{

break;

}

result = TRUE;

}

if(!(result))

{

this->InvalidateDeviceContext();

}

return result;

}

void Tab::Icon::DeleteDeviceContext()

{

if(this->deviceContext)

{

if(this->originalBrush)

{

(void)this->deviceContext->SelectObject(this->originalBrush);

}

if(this->originalBitmap)

{

(void)this->deviceContext->SelectObject(this->originalBitmap);

}

delete this->deviceContext;

}

void Tab::Icon::InvalidateDeviceContext()

{

this->deviceContext = NULL;

this->originalBitmap = NULL;

}

CDC* Tab::Icon::GetDeviceContext()

{

return this->deviceContext;

}

Here is what happens. First, a bitmap is created that is compatible with the CPaintDC, the full-color screen device context onto which the icon is to be painted:

CBitmap iconBitmap;

if(!(iconBitmap.CreateCompatibleBitmap(targetContext,Constants::HeightWidthIcon,Constants::HeightWidthIcon)))

Then a device context that will serve as the buffer of the painted icon is created:

this->deviceContext = new CDC();

this->deviceContext->CreateCompatibleDC(targetContext);

Next, within that buffer, the bitmap is painted with the background color, and then with the icon:

CBitmap* originalBitmap = this->deviceContext->SelectObject(&iconBitmap);

HGDIOBJ originalBrush = this->deviceContext->SelectObject(this->backgroundBrush);

if(!(this->deviceContext->PatBlt(0, 0, Constants::HeightWidthIcon, Constants::HeightWidthIcon,PATCOPY)))

{

break;

}

if(!(this->deviceContext->DrawState(

CPoint(0,0),

CSize(Constants::HeightWidthIcon,Constants::HeightWidthIcon),

iconHandle,

DST_ICON|DSS_NORMAL,

(HBRUSH)NULL)))

{

break;

}

Finally, the buffer is swapped onto the CPaintDC:

deviceContext->BitBlt(this->areaIcon.left,this->areaIcon.top,Constants::HeightWidthIcon,Constants::HeightWidthIcon,memoryContext,0,0,SRCCOPY); //deviceContext is CPaintDC, whereas memoryContext is the CDC* buffer.

Working around a WebBrowser ActiveX control resize bug of which you may or may not have been aware

2011-12-31T21:46:27Z

If you are hosting the WebBrowser ActiveX control in a native code application (perhaps following these instructions, then you may or may not have noticed that the control does not always resize correctly. Specifically, if you maximize the application, then the same functions that will work properly to maximize any other child control (MoveWindow or SetWindowPos) won't always serve to maximize the WebBrowser control properly. Even more specifically, what one might observe on certain pages (and I've found the MSDN homepage to be the foremost victim) is that although the control will maximize, it won't be repainted, or at least, not quickly--after a while it will eventually fully repaint itself at the new dimensions. I tried lots of workarounds, including getting hold of the document itself and telling it to resize itself, and also this workaround for ActiveX control re-sizing: http://www.cherea.de/bitbucket/resizeaxctl/resizeaxctl.html. What does work is simply instructing the control to repaint itself, this:

this->MoveWindow(area.left,area.top,area.Width(),area.Height(),FALSE);

this->RedrawWindow(area,NULL,RDW_UPDATENOW|RDW_ALLCHILDREN);

Steve Jobs ...

2011-10-06T00:06:08Z

... you so changed the world ... thanks for making lives like mine possible. RIP.

A Windows Communication Foundation JSONP Service

2011-08-14T03:00:00Z

All of the samples I've found that show how to build a JSONP service using the Windows Communication Foundation have the thing hosted in IIS. IIS is literally the last place I want my Windows Communication Foundation services hosted ... especially because I'll only want them in IIS once I've debugged them, and debugging outside of IIS is much more efficient. Here is a console version of such a service:

using System;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Web;

namespace Server
{
    [DataContract]
    public class Some
    {
        [DataMember]
        public string What;

        [DataMember]
        public string Why;
    }

    [ServiceContract]
    [JavascriptCallbackBehavior(UrlParameterName="method")]
    class MyService
    {
        [OperationContract]
        [WebGet(ResponseFormat = WebMessageFormat.Json)]
        public Some GetSome(string input)
        {
            return new Some() { What = "A Shotgun", Why = "Needs an Outcome" };
        }
    }

    class Program
    {
        const string BaseAddress = "http://localhost:8888/MyService/";
        const string EndpointAddress = "MyEndpoint";

        static void Main(string[] args)
        {

            using(ServiceHostBase serviceHost = new ServiceHost(typeof(MyService),new Uri[]{new Uri(Program.BaseAddress)}))
            {
                WebHttpBinding binding = new WebHttpBinding();
                binding.CrossDomainScriptAccessEnabled = true;
                ServiceEndpoint endpoint = serviceHost.AddServiceEndpoint("Server.MyService", binding, Program.EndpointAddress);
                WebHttpBehavior behavior = new WebHttpBehavior();
                WebScriptEnablingBehavior scripting = new WebScriptEnablingBehavior();
                endpoint.Behaviors.Add(behavior);
                endpoint.Behaviors.Add(scripting);
                serviceHost.Open();
                Console.WriteLine("Press <ENTER> to terminate this program.");
                Console.ReadLine();
            }
        }
    }
}

And here is the HTML page that you can open in the current version of any major browser to see the output from the service:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
    <title>Untitled Page</title>
    <script src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.5.1.js" type="text/javascript"></script>
    <script type="text/javascript">
        function callback(data) {
            alert("Like a " + data.What + " " + data.Why);
        }
        $(document).ready(
            function () {
                $("<p>Hello, I am Dynamic Text!</p>").appendTo("body");
                $("<p>Attempt</p>").appendTo("body");
                $.getJSON("http://localhost:8888/MyService/MyEndpoint/GetSome?method=?", callback);
                $("<p>Done</p>").appendTo("body");
            }
        );
    </script>
</head>
<body>

</body>

</html>

Integrating a desktop application with Windows Live

2011-07-15T17:47:02Z

If one searches the Web for samples of how to integrate a desktop application with Windows Live, unfortunately one finds one's way to material that is out-of-date. So here is some code that works as of July 2011. The code is for a Windows Form that has a browser control and a text box. The only modification you will need to make to the code is to alter the ApplicationIdentifier constant to point at the identiifer of your own application registered at https://manage.dev.live.com. The code navigates the browser control to the Windows Live authentication page. The browser control handles the navigation event to sniff at the locations to which it is redirected. Upon navigation to a location that signifies successful authentication, the location is parsed for the access token. Given the access token, the application can retrieve the user's information. The DataContractJsonSerializer is used to parse the response to the request for that information.

using System;

using System.Globalization;

using System.IO;

using System.Linq;

using System.Net;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Json;

using System.Windows.Forms;

namespace LiveID

{

public partial class Form1 : Form

{

const string ApplicationIdentifier = "0000000000000000"; //YOUR APPLICATION IDENTIFIER GOES HERE

const string AuthenticationHost = "oauth.live.com";

const string AuthenticationLocalPathDesktop = "/desktop";

const string AuthenticationResourceTemplate = @"https://{0}/authorize?client_id={1}&response_type=token&scope=wl.signin%20wl.basic&redirect_uri=https://{0}{2}";

const string ContentTypeText = "application/text";

const string KeyAccessToken = "#access_token";

const string MethodGet = "GET";

const string ResultTemplate = "User Name: {0}; Identifier {1}";

const char SeperatorQuery = '&';

const string UserResourceTemplate = "https://apis.live.net/v5.0/me?{0}";

public Form1()

{

InitializeComponent();

}

private void Form1_Load(object sender, EventArgs e)

{

this.webBrowser1.Url =

new Uri(

string.Format(

CultureInfo.InvariantCulture,

Form1.AuthenticationResourceTemplate,

Form1.AuthenticationHost,

Form1.ApplicationIdentifier,

Form1.AuthenticationLocalPathDesktop));

}

private void webBrowser1_Navigating(object sender, WebBrowserNavigatingEventArgs e)

{

Uri location = e.Url;

if ((location.Host == Form1.AuthenticationHost) && (location.LocalPath == Form1.AuthenticationLocalPathDesktop))

{

string[] fragments = location.Fragment.Split(Form1.SeperatorQuery);

string token = fragments.Where((string item) => item.StartsWith(Form1.KeyAccessToken)).FirstOrDefault();

if (!(string.IsNullOrEmpty(token)))

{

WebRequest request = WebRequest.Create(new Uri(string.Format(CultureInfo.InvariantCulture,Form1.UserResourceTemplate,token.Substring(1))));

request.Method = MethodGet;

using(Stream responseStream = request.GetResponse().GetResponseStream())

{

request.ContentType = Form1.ContentTypeText;

User user = (User)new DataContractJsonSerializer(typeof(User)).ReadObject(responseStream);

this.textBox1.Text = string.Format(CultureInfo.CurrentUICulture,Form1.ResultTemplate,user.Name,user.Identifier);

}

[DataContract]

partial class User : IExtensibleDataObject

{

ExtensionDataObject extendedData;

[DataMember(Name = "id")]

internal string Identifier

{

get;

set;

}

[DataMember(Name = "name")]

internal string Name

{

get;

set;

}

public ExtensionDataObject ExtensionData

{

get

{

return this.extendedData;

}

set

{

this.extendedData = value;

}

The Artificial Intelligence Oxymoron

2011-05-22T02:15:21Z

I'm reading Stephen Levy's wonderful book about Google, In the Plex. In the account of the development of AdSense, an engineer explains the process of having software understand a Web page well enough to match its content with an advertisement. He says that fundamentally the problem is that of enabling a machine to accept a stream of words as input and correctly predict the words that come next. Google's indexing of the entire Web and some of the rest of the world's information gives it a tremendous amount of material from which its software can learn to accomplish that feat.

Anyone who has read Jacques Derrida will note with interest how Google's computer scientists have arrived at the same perspective on semantics that philosophers did with Derrida's publication of On Grammatology: that meaning is not complete at the current location in a stream of language, but is always only being completed by the subsequent location. Derrida, of course, called this essential aspect of semantics "differance."

In the next paragraph of In the Plex, the engineers speculate on the prospect of the machine ascending to artificial intelligence by using the repository of data at its disposal to acquire more knowledge and linguistic understanding. That's the point at which their thinking departs from Derrida's.

They're absolutely right to recognize that intelligence is linguistic, that it is demonstrated by fundamentally linguistic capabilities. What computer scientists generally don't see is that the use of language, and therefore, the capacity for intelligence is essentially organic.

That's because the use of language is driven by desire. If the meaning of a stream of language is always within the context of what comes next in that stream, then it is desire that drives a user of that language onward in that stream.

An understanding of the nature of that desire is to be found somewhere between the writings of Karl Marx, Charles Darwin and the early Jean Baudrillard: most likely the latter. Jacques Lacan explained how desire draws infants into language.

Machines have no desire. So while they can be made to appear as if they have linguistic capability, they simply don't. They may be able to take a stream of language as input, and predict how that stream will continue, but they will never care about whether the stream actually does continue or not.

So we can program machines to win at poker or chess. We can't make they care about winning or losing, though, and therefore, we can't ever make them play those games or any others, just make the moves.

That's why I find "artificial intelligence" to be an oxymoronic term. Intelligence is linguistic and linguistic capability is irreducibly organic. Nothing about intelligence is artificial, and nothing artificial can be intelligent.

Two IE 9 Tips

2011-03-24T02:27:42Z

Selecting a Particular Home Page in Internet Explorer 9:

I have 5 home pages that I add to Internet Explorer on every machine I use as a productivity workstation. In version 8, I routinely go over to the drop-down arrow next to the home icon and select a particular home page. That drop-down arrow is missing, by default, on Internet Explorer 9. The home icon over on the right will load all of one's home pages, as it did before. To get the "old" home icon, with the accompanying drop-down, one must choose to have the menu bar visible, which it isn't, by default.

Using Acrobat Reader in Internet Explorer 9:

Yikes! Where did the menu go, which I would use to get the resolution I want? Turns out that if one hovers the mouse over the lower part of the page, towards the middle, controls appear that allow one to turn on the menu, as well as manipulate the view directly.

Re-discovering '1984'

2011-01-22T18:05:14Z

I can't listen to Goldfrapp, The Ting Tings, and The Scissor Sisters exclusively. Goldfrapp's art, in particular, always absorbs my concentration. So I'm always on the lookout for stuff to have in the background. A few weeks ago, I had Escovedo's wonderful 'A Man On the Wire' in heavy rotation. This week, I've rediscovered an album I had on vinyl as a kid when it first came out in '81: Rick Wakeman's '1984,' which is essentially the soundtrack to a prog rock opera inspired by the Orwell novel.

In-Process Transport for the Windows Communication Foundation

2011-01-22T01:20:00Z

I recently had a case where a thread running under one identity would process data periodically provided by a thread running under a different identity. There are lots of ways of accomplishing this, but the priority for me was to do it in such a way that the purpose of all of the code would be clear. Describing the receiver as a service, and the sender as a client was attractive for that reason, and using the Windows Communication Foundation semantics in so doing was even more attractive. However, the threads would always be within the same process, and the Windows Communication Foundation does not include an in-process, cross-thread transport by default. So I wrote a simple one. Its attached to this post for anyone else who might find it useful. It isn't a bad illustration of a custom Windows Communication Foundation transport either. In fact, I would almost certainly use it in Windows Communication Foundation Unleashed if I was writing that book now.

"Real-World Functional Programming" ...

2011-01-19T18:59:10Z

... is a book by Tomas Petricek and Jon Skeet. It's terrific. It succeeds not just as an introduction to functional programming and F#, but also as a simply excellent programming text.

The reason it is superior is that the authors strived to teach concepts and the application of concepts, rather than simply convey the details and applications of a particular technology. I set out to do that with Windows Communication Foundation Unleashed, but never succeeded, so I appreciate the challenge they faced.

Readers will not only learn the ideas, but also get trained to see applications for them, as well as acquiring knowledge of the tools. This book is my candidate for the best programming book of 2010.

Who's cryin'? Who's cryin' now?

2011-01-06T20:11:51Z

Everyone. RIP Gerry Rafferty. Done too soon.

WeatherBug Live Tile is back ...

2011-01-06T20:10:10Z

... Once I added a new location, set that as my Live Tile location, confirmed Live Tile update, and then deleted that location and set my original one as the Live Tile location. Phew.

WeatherBug Push/"Live Tile" Notification for Windows Phone has been broken for about a week now ...

2011-01-02T19:02:18Z

... which explains why I find myself surprised that it has actually been clear and freezing in Sammamish, WA, for the past several days, rather than rainy and 7 Celcius as my phone has led me to expect.

Selecting a Windows Phone device

2011-01-02T18:18:00Z

Of the very many people I know who have Windows Phones, all of them except one opted for the Samsung Focus. The odd person out happens to be me, who chose the LQ Quantum.

My choice was simple. The Quantum is the one with the hardware QWERTY keyboard and I badly wanted a phone with that feature. I'd used the virtual keyboard on my Zune HD to know that the virtual keyboard on the phone would be fine for entering one or two words into a text box, but not for anything longer, such as typing an e-mail. The virtual keyboard on my Spring Design Alex e-reader is better, but that's only because the screen is considerably larger. Whereas reviews of the Quantum indicated that the keyboard does not slide out easily, I haven't found that to be the case. It takes just the slight push that one would expect, yet has never slid out when I didn't want it to do so.

I subsequently learned that the Quantum has twice as much memory as the Samsung Focus. However, the memory on the Focus can be expanded with a memory card, which the Quantum does not support. I noticed that as a result of users querying about how to get the memory cards to work properly in the Focus.

That discovery has left me in some awe of the buzz around the Focus. The Focus seems to be sold based on being a bit lighter and having a slightly larger, brighter screen. The Quantum has the hardware keyboard in addition to the virtual one provided by the operating system, and twice as much built-in memory.

Thus, the choice seems to be between two more qualitative benefits of feeling lighter and seeming brighter, against the binary benefit of having a physical keyboard and the more quantitative benefit of having more memory. Of course, being lighter is a decidedly quantifiable benefit, too, but one that only matters if the quantifiable weight difference is actually noticeable when carrying the device around. So whereas there is a quantifiable weight difference, the selling point is actually the qualitative one of the device feeling lighter.

Yet 99% of consumers in my experience are opting for the Focus. Wow! And all but one of those are men, who, stereotypically, are meant to be charmed by quantitative characteristics.

Let me be quite emphatic. I'm sure that all of the current Windows Phone models are terrific, and I'm ecstatic with mine.

My point is merely that whoever built the buzz around the Focus is worthy of a big commendation. The evangelism for that device has been an overwhelming success.

Controlling the orientation of a Windows Phone (Hacking the accelerometer)

2011-01-02T17:15:00Z

Windows Phones, by definition, are equipped with an accelerometer for detecting the physical orientation of the device. Applications can subscribe to notifications from the operating system of orientation changes and adjust their layouts accordingly. Early reviews of Windows Phones were apparently in consensus that few applications would be orientation-aware. I've encountered just one, I think, that evidently wasn't orientation-aware, however. What often happens is that the accelerometer and I are in disagreement about the orientation of the device. I'm holding it, according to my senses, upright, whereas it's telling the operating system that it is being held sideways. that's particularly relevant when using Internet Explorer, because it's useful favorites bar doesn't seem to show up in landscape orientation. Here is how to force the accelerometer to notify applications that the device is being held upright and that portrait mode is therefore desired. Hold the device so that the top thereof is parallel to your chin. Then--and this is the crucial step that informs the accelerometer unequivocally that the device is upright--tilt the top of the device toward your chest for a moment. That may cause the screen to pass out of view for a moment, as you find yourself looking down at the top and rear of the device. Yet, as you tilt the device back so that you can see the screen, then you should find that any application that had gone into landscape orientation is back in portrait orientation.

Santa Cookies: Always my favorite part of the holiday season

2010-12-18T20:22:46Z

After nearly twenty-years, I'm always delighted when my wife treats us to her Santa cookies:

Forget Patterns ... What matters are software maintenance practices

2010-02-03T20:23:00Z

Software Engineering is Still a Risky Enterprise

The problems in being able to produce and maintain software with predictable success were documented almost at the dawn of the profession, by Frederick Brooks, Jr., in his essay, “The Mythical Man-Month.” The persistence of those problems, as well as the lack of established solutions was confirmed as recently as 2007 by Scott Rosenberg in his book, Dreaming in Code. Both Brooks and Rosenberg emphasize that the science of computing runs aground in the process of software engineering because software engineering is a process accomplished by groups of people and the coordination of those people tends to be problematic.

Perhaps an obstacle in the way of solving that problem is the fact that, of all people, computer programmers are prone to thinking that problems can be solved with software. Thus, they tend to think of the maintainability of software as an intrinsic attribute thereof. That is, they tend to think that one piece of software is more maintainable than another principally, or even solely, because of differences in how those pieces of software are written.

However, if the production and maintenance of software is actually a social endeavor, then it is better accomplished when the social process of software production and maintenance is designed in addition to the software entities themselves. In their book, Do You Matter? How Great Design will Make People Love Your Company, Robert Brunner and his co-authors document various successful efforts in the design of social processes incorporating engineering products. They document the successful engineering, not just of a product, but of the entire process by which humans incorporate those products into their lives. The achievements they document are not in the development of a wonderful software user interface for the product, but rather in the development of a way of living and working with the product that extends well beyond its user interface to the tasks of choosing the right model, ordering it, learning how to use it, getting it repaired, and so on.

Other Professions Explicitly Design How Their Work Is Done

Indeed, in other enterprises, the design of the human processes incorporating the engineered product is often commonplace. Consider the production of artwork. That enterprise provides a particularly compelling example, because whereas the production of software is commonly assumed to be closely related to the science of computing and to involve great precision, the production of artwork is thought to depend on innate talent and inspiration, and would therefore, presumably, be less predictable.

In fact, professional artists successfully impose predictability onto their work by devoting effort to the design of their activity separately from the design of their artwork. The term artists use for thinking about their activity is workflow. There are standard workflows that are known to be successful, and professional artists routinely consider and debate the virtues of those. A workflow breaks an artist’s labor down into constituent activities, which makes it possible for them to estimate the duration of those activities for a given project and to calculate costs. The scale of one project versus another can be computed by comparing the durations of the various activities for each project.

Another example of the design of human processes to ensure maintainability and predictability can be observed whenever one takes one’s automobile in for maintenance or repair. One can readily observe how the automobile is processed through a workflow that begins with obtaining information from the owner, proceeds through diagnosis, estimation, and repair, on to notification of completion and receipt of payment. Again, the organization of this process is decidedly not accidental or variable from day to day. It has been designed and optimized, and organizations compete on the basis of the quality of that design. Indeed, a thesis of Brunner and his colleagues in Do You Matter? is that commercial organizations increasingly complete on the basis of the quality of the design of their human processes, their actual products having become interchangeable in terms of features, quality and price.

Software Engineers Do Not Design How Their Work is Done

In software engineering, a commonly-accepted principle is that an iterative development process is to be preferred over a sequential one. So today, the development of most non-trivial software proceeds by producing one working version after another, incorporating feedback on the previous one into the development of the next, and so on, throughout its useful life. By implication, the software will always be undergoing modification.

During these iterations, the software and the modifications to it are generally designed in advance, or at least, everyone would agree that should happen. Also, the process of gathering and documenting requirements is planned in advance, and so are the testing procedures that the software will undergo.

What usually is not explicitly designed, though, is the process by which the software developer will interact with the software during the iterative process of modifying it. Before the software is built or changed, the developer may offer blueprints for review, but those almost never describe how the developer will be able to reproduce a bug that someone may find in the software after it has been completed, or how the developer will identify the cause, or later confirm that the defect is fixed without inadvertently creating another one. Rather, it is invariably assumed that all of that will go smoothly provided the developer is competent. That assumption is both faulty and risky, however.

The assumption is faulty precisely because, as Brooks emphasized, software is usually not produced by capable individuals toiling alone, but rather by a number of people working together. One developer may well make changes to a component of a software system that will disrupt how another developer has been accustomed to debugging that component. For example, this writer has spent the last several years as part of large team developing a commercial product of which one component is a Windows service. At the beginning of the project, it was possible to start the service under the Microsoft Visual Studio debugger. Then someone made a change to the service by which it would never successfully start in that environment. From then on, if one wished to attach a debugger to the service, that had to be done after the service was installed and running. Consequently, debugging errors that occurred as the service was starting became very difficult. This unfortunate side-effect of the change was not anticipated because the existing processes for developing the service were never documented or even discussed, and the preservation of those processes was never prioritized.

Just assuming that developers will be able to readily figure out how to make changes to software just because they are qualified to work as programmers is risky for several reasons. One is that the personnel on a project change over time so the person who initially developed some component is seldom the person who will later be required to maintain it. Also, if only one or two developers know how to go about modifying some part of the system, then a release may be blocked on them resolving a number of defects while other developers are idle. Most importantly, if a software system is developed iteratively over its lifetime of use, then the primary concern should be to ensure that the process for accomplishing that iterative development is documented and effective for every one of the components. Yet that is precisely the process that is simply left to chance! At the logical extreme, a piece of software with many significant flaws, but which one knows how to quickly and reliably fix, is decidedly more valuable than one that has just one or two significant flaws, but which is practically impossible to repair. Whereas the former might well be released after a period of time that one could accurately estimate, the latter probably never would be.

Simple, Actionable Recommendations

Once the importance of designing how software is to be maintained is recognized, the actions to take become readily apparent, and are quite straightforward. First, before a developer is to initiate the construction of a software entity, or any significant alteration to it, the developer must provide not only a satisfactory design of the entity itself, but also an explicit and acceptable account of the process by which the software is to be maintained. Second, in evaluating alternative designs for the software, the implications of those alternatives for the processes of maintaining the software must be taken into account. Third, the cost of establishing and executing the maintenance processes must be factored into the overall estimation of the project.

Explicit Designs of Maintenance Processes

In the server this writer’s team has been developing, input is received via HTTP and electronic mail, and the implications of every input have to calculated before a decision can be made about whether the input is permissible. The algorithm for that calculation is complex, and is currently implemented using a number of Transact-SQL stored procedures. There have probably been more defects found in the implementation of the algorithm than anywhere else in the system. However, that state of affairs is significantly less worrisome that it would otherwise be, because there is an effective procedure for investigating the defects, testing the remedies, and guarding against regressions. By virtue of there being a known and effective procedure for handling the problems, the time to fix each one can be accurately estimated, and that time is generally brief even though the code is complex. Any reported defect can be described in an XML format that captures both the input that reportedly resulted in the defect, as well as the nature of the error itself. The XML is used as input to a test driver, which proceeds up to the point at which the error is expected to occur. At that point, it alerts the developer providing a numeric value that can be used as input to a second driver that executes the stored procedures, and displays the state of the calculation at every point. Crucially, all of this is reliably idempotent, so the developer can repeat the process as many times as may be necessary to complete the investigation and validate the fix.

Without this effective procedure for maintaining a critical and complex part of our server, the release schedule would have been jeopardized. Yet, in preparation for developing this component, what was prepared and scrutinized were detailed designs of the algorithm and the implementation, and not the process for maintaining it. However, those original designs of the algorithm are no longer accurate models of the actual code, while it the maintenance procedure has proven to be very important.

The lesson to learn from this experience is plain. Do not leave the existence of a sound maintenance procedure to chance.

In Planning Changes to Software, Take the Effects on the Processes for Maintaining the Software into Account

Our server accepts queries in the form of XPath expressions. Transact-SQL queries are generated from the XPath expressions, and the Transact-SQL queries are executed to retrieve the data matching the query from our data store.

An XPath parser produces an object model representation of the inbound query, and a SQL generator yields the executable Transact-SQL version. In the process of figuring out the optimal schema for our data store and the best way of structuring the complicated Transact-SQL queries, we interposed an XML representation of the query between the XPath parser and the SQL generator. So, at that point, the XPath parser produced the object model representation of the query, which was then represented as XML and passed to the SQL generator. That arrangement was useful because a library of XML documents representing various queries could be created then used as input for testing various versions of the SQL generator in isolation. Several iterations of the SQL generator were being produced each week at that point, as we evaluated different schema and various query strategies.

Once we settled on a schema and a way of formulating our SQL queries that yielded satisfactory performance for all of our diverse query test cases, we considered whether to remove the step of producing an XML representation of a query before generating the Transact-SQL version Yielding the Transact-SQL directly from the object model representation would be faster, because it would eliminate a step.

Due the complexity of our queries, the time to execute them generally dwarfs the time to translate it from XPath into Transact-SQL, regardless of whether we express the query as XML in between. On the other hand, having the XML to isolate the SQL generator from the rest of the server had become crucial to our process for maintaining the SQL generator. Whenever a defect was found in our query feature, it was invariably due to the Transact-SQL not returning the correct results, or not executing quickly enough, or being syntactically erroneous. We’d produce the XML representation of the query that caused the error once, and execute the SQL generator by itself, using that XML as input, and examine the Transact-SQL that got produced in SQL Server Management Studio. Once the error in the Transact-SQL was identified and the SQL generator modified to correct it, the generator would be tested in isolation against our library of XML representations of queries, which was now expanded to include the one for the most recent failure case.

Prior to having the XML version of a query as input to the SQL generator, when the SQL generator took to the object model representation of the query as input, debugging the SQL generation was decidedly more difficult. It required installing and executing the service and attaching a debugger to that, then sending in the query from a client application, and using the debugger attached to the service to examine the representation of the query in memory and step through the SQL generation code. Adding to the difficulty and duration of this process was the fact that our standard client does not allow a user to send an XPath query to our server directly. Instead, it provides a graphical user interface for building a query that the client translates into XPath for transmission to the server. So, because we didn’t think to maintain a client dedicated to sending arbitrary XPath expressions at our service for the sake of debugging queries, whenever we had to debug a query, one of us had to build a client for transmitting the XPath query to the service by scavenging the code for that purpose from the code for the standard client.

Thus, the answer to the question about whether we should improve performance by removing the step of producing an XML representation of a query in the process of translating it from XPath into SQL was a firm “no.” If the question was considered purely in terms of the software, then the answer might well have been “yes,” because the software would have been simplified, perhaps, by the omission of a step, and its performance improved, albeit just a little. It is when the issue is considered in terms of the process by which the software is maintained that the correct answer is readily apparent. In this case, it is hard to justify the step of representing the query as XML in terms of the design of the solution, and especially difficult to justify it with respect to the functional requirements. Yet, it is crucial for the human process of servicing the query generator.

Estimate the Cost of Software Engineering Projects from the Costs of the Processes for Maintaining Each Component

Brooks maintained that a software development project ends up a year behind schedule one day at a time. One might add that days are lost one hour at a time.

Our project ended up a year behind schedule. It is not difficult, in retrospect, to explain why all those additional hours that proved to be necessary were not anticipated at the outset.

The developers spent time designing and building, over and over again, the tools they needed to fix the bugs. The time to build those tools once, and properly, was an inevitable expense. However, it was never correctly incorporated into the project’s estimates. Furthermore, the overall time could have been reduced if the tools were designed explicitly and if they were shared and maintained and not accidentally broken.

The time that ended up being absorbed by the steps involved in reproducing and fixing bugs was not fully taken into account in the estimates for several reasons. One is that software developers tend to estimate based on attributes of the software they are to develop, such as lines of code and function points, rather than in terms of tasks that human beings perform, even though it is those tasks that take time. Another reason is that, in the process of reviewing designs in anticipation of starting to code, no-one ever asked the developers if they had thought about how they would go about investigating and fixing bugs, validating their fixes, and guarding against regressions. That is work that will inevitably have to be done on any software development project, but how that work will be done is not planned in advance or accurately budgeted.

Because there is no physics by which the time absorbed by the concrete steps of maintaining software can be made to disappear, the manner in which the duration of software development projects is estimated has to change. The estimation should be based on estimates of the time a person will take to execute each definite step in an explicitly designed process. Once the estimation is done on that basis a number of benefits will result.

First, management will insist on developers deliberately planning how they are going to do their work, in addition to designing their software. So the process by which the software is to be maintained will no longer be left to chance.

Second, estimation will become more accurate. It will be more accurate because it will be based on what actually takes time, which is people doing things, rather than being based on lines of code or function points or some other attributes of the software to be built. None of those attributes can properly be said to have a duration. The estimation will also be more accurate, because once developers have a reliable process for maintaining a particular component, they will be able to base their estimates on the time that they know the steps of that process will consume. For example, if a developer has a reliable process for reproducing any defect in a particular component, diagnosing the cause, validating the fix, and excluding regressions, then the developer will be able to accurately estimate the time to fix any defect. Without such a process, any estimate will be suspect.

Third, the wisdom or otherwise of a proposed change will be properly assessed in terms of its impact on the schedule, because its effect on the software maintenance process will be manifest rather than accidental. What constitutes a regression will no longer just be a change that results in a new functional defect, but also one that makes it harder for the team to do its work, both of which are outcomes that can delay a schedule.

Conclusion

Software engineering is thought to be a risky enterprise because large, unforeseen difficulties are often encountered. Yet, serious unforeseen difficulties occur in every enterprise. Moreover, software engineers take the prospect of those difficulties into account in exactly the same way that folk in other enterprises do, which is by adding contingency time to their estimates. What tends to happen, though, is that the projects end up massively behind schedule no matter how much time was allocated for contingencies. So it really isn’t the unforeseen difficulties that invalidate the estimates. It is actually because the estimates are supposed to be of the time it will take for a person to complete a task, yet those tasks are seldom identified in advance by a plan of what will actually be done, and from which the durations of the tasks might be estimated. Instead, the estimates are based on ideas the developers have about the software, which are captured in their designs.

Thinking harder about software has not made software engineering a more reliable enterprise. What might help is focusing on the steps in the process by which people build and maintain software.

The Wacom Intuos 4 Tablet is terrific

2009-10-18T17:50:00Z

I've been interested, recently, in improving my digital art skills from their current state of being entirely non-existent. As a developer, I wish to be capable of doing more attractive user interfaces for applications I'm mocking up.

As an initial project, I thought I would design cover art for my novel, Lady Sacrilege. I immediately found myself hampered, in that endeavor, by the quality of my graphics tablet, an inexpensive Genius tablet. I'd been thinking about what to trade up to for several months actually.

Wacom thoroughly dominates the graphics tablet market, so naturally, my choice became a matter of deciding which Intuos tablet to buy. I'd mulled over a Cintiq, because I thought that not being able to draw directly on the tablet surface, as one is accustomed to doing on paper, would always be an obstacle.

What caused me to hesitate was less the price tag than the uncertainty of whether I could get it to work with my existing dual-monitor set-up, switching between the Cintiq and my existing second monitor with a switchbox. Wacom's sales support was not positive that would work.

On this past Friday, I finally made a decision and picked up an Intuos 4 medium tablet at Best Buy. If you go looking for one there, you'll find the less expensive Bamboo models with Best Buy's Mac peripherals, and if you ask a staff member in the computer department whether they have the Intuos models in stock, he or she will likely tell you, as they told me, that the Intuos models are only available online. Actually, a nice variety of Intuos tablets are to be found in the Best Buy's photography section, so one can indeed take one home right away if one wishes to do so.

Well, I found it to be a wonderful piece of equipment. I immediately lost any sense of being limited by not being able to draw directly on the tablet surface. The hand-eye coordination that I thought I would never develop was simply there. The fact that my eye was not watching my hand was just not an issue anymore.

That still doesn't mean I'm any good at digital artwork. Of course not: I've only just started trying my hand at something for which I have little aptitude. But what I'm still lacking is the artistic imagination and enormous experience with graphic software that doing fine digital artwork requires. The Intuos has entirely solved the input problem. And even in the short time I've spent with it, I've already appreciated its incredible pressure sensitivity and even the tilt sensitivity that is unique to the Intuos line.

As far as I'm concerned, then, the answer to the question of how one can draw using one's computer is "with an Intuos 4." Thank you, Wacom, for producing a remarkable device.

Parenthetically, one gets to choose which bundled software one prefers. I found that other Intuos users were recommending Corel's Sketch Pad. Indeed, I'm very impressed with that software as well. I printed out the pencil outline of the figure in my cover art on my color laser printer, and was delighted to see on the paper precisely a pencil sketch--the textures were exactly what I would have produced with a lead pencil on the same paper. And the Sketch Pad user interface is masterful: just perfect for navigation with a pen.

Here's the initial pencil sketch of Lady Sacrilege:

I fixed her chest and slimmed her down when I inked the sketch:

And here is the finished cover concept, minus some touch-ups I'd like to make to the head, especially on the right side:

Microsoft Identity Lifecycle Manager "2:" Careful of how you use those question-and-answer gates

2008-10-20T15:46:00Z

One of the features of Microsoft Identity Lifecycle Manager "2" is self-service password re-set. That feature sits on top of a generic facility of the Microsoft Identity Lifecycle Manager service that provides for multi-factor authentication.

To explain, one can define any number of management policy rules in Microsoft Identity Lifecycle Manager "2," each of which may apply, according to your choice, to a narrow or a broad a variety of operation that users may attempt to perform. Among other things, those rules may specify whether additional confirmation of the user's identity is necessary before permitting them to perform the operation. In Microsoft Identity Lifecycle Manager "2" that addtional confirmation will always be in addition to a Kerberos token identifying whoever it was that initiated the operation. If additional confirmation is required, then the management policy rule will identify the definition of a authentication workflow that must complete successfully before the requested operation willbe allowed to proceed. An authentication workflow will typically incorporate one or more activities for obtaining additional confirmation of the identity of whoever requested the operation, confirmation that could cover any number of authentication factors.

Microsoft Identity Lifecycle Manager "2" ships with one type of activity for corroborating identity: a question-and-answer activity. If one was to use that activity as a means for corroborating the identity of someone attempting to re-set their password, then that activity would present questions to the user for which the user would have previously provided the answers, during the process of registering to use the password re-set facility. So, for instance, the user might be confronted by any number of questions to confirm their identity, such as their mother's maiden name, the city of their birth, the make of their first car, and so on.

Now, as you may have read, a person was arrested last week for breaking into U.S. vice-presidential candidate Sarah Palin's Yahoo e-mail account. He is accused, apparently, of re-setting the password on the account, and publishling the new password on the Web, among other misdeeds. The account's privacy was protected by question-and-answer authentication gates. The lesson here is that if you are public figure, especially one as a visible as a candidate for U.S. federal executive office, then one will be afforded precious little protection by question-and-answer gates. While most people will not know the answers to even a few commonplace questions about your life and mine, unfortunately, if you are a candidate for high office in a democracy with a free press, then anybody will be able to ascertain the answers to those same questions, in your case.

Body of Lies

2008-10-20T15:31:00Z

I read a lot of spy fiction. I have observed that the sociology of an espionage organization, as depicted, especially by Len Deighton, is very similar to that of a software development enterprise. While I may expand on that observation in more detail here, at some point, suffice to say, now, that in both cases, there are people who go over the wall, as it were, and people who do not, and things only work well when those two groups function well together, and share the same priorties, and unfortunately, they often do not.

Anyhow, last weekend, while on what Bridget Jones referred to, in her famous diary, as a mini-break, I read David Ignatious' spy novel, Body of Lies. The film version of that book opened in wide release across the United States last weekend as well, and the review I read in The Seattle Times was not favorable, and the film did not perform very well at the box office. I have not seen the film, but from the review, it is apparent that the character played by Russell Crowe has been adapted somewhat for the screen. The reviewer also questioned whether there is room, in such a tale, for a romantic interest, which is odd to someone who had only read the book, because that romantic interest is the central plot element in the novel, the one that drives all the action toward its climax. So the question of whether there is room for a romantic interest in the story is rather like asking whether there is room for the character of Teresa di Vicenzo in On Her Majesty's Secret Service.

Regardless, as I say, I have not seen the movie, but the book is terrific.

Microsoft Identity Lifecycle Manager "2:" Some definitions you may find useful

2008-10-20T15:22:00Z

Requests

In the argot of Microsoft Identity Lifecycle Manager, a request is a request to perform some operation on resource or on all or some of the attributes of a resource. The resource to which a request refers is generally known as the target of the request.

Sets

A set is a named collection of resources identified by a given filter expression, plus any resources that are added to the set regardless of whether or not those resources match the filter expression. Resources that are added to a set regardless of whether they is identified by the set's filter expression, are referred to as explicit members of the set, and the act of adding or removing such members is referred to as explicitly adding or explicitly removing a resource.

Recursive Sets

Recursive sets are sets with recursive filter expression. A recursive filter expression incorporates a secondary filter expression, and also names an attribute. The set includes every resource identified by the named attribute of any resource that is identified by the secondary filter expression, and it also includes every resource identified by the named attribute of any resource that is a member of the set. The attribute named by the filter of a recursive set will be referred to, below, as the recursive set's recursive attribute.

Set Membership Conditions

A set has membership conditions which are used to determine whether any given resource, in any given state, at any given point in time, belongs to the set. Each membership condition consists of one or more statements, each of which must be true for the given resource, in its specified state, if the resource, in that state, is to satisfy the membership condition. A resource must satisfy at least one of the membership conditions of a set in order for it to be among those resources identified by the filter expression.

Each statement of a membership condition is an assertion about the value of an attribute of a resource. Therefore, whenever an attribute of a resource is to be modified by a request, one can identify the membership condition statements that pertain to that attribute, and, thereby, identify the sets that the resource may join or leave as a result of the modification.

Management Policy Rules

Management policy rules stipulate who can request which changes to which resources. They also specify which workflows must be executed at which stage in the processing of a request.

Request Evaluation

When a request is submitted, a representation of the request is created in the Microsoft Identity Lifecycle Manager data store. Then the implications of the management policy rules for the request are determined. That step of determining the implications of the management policy rules for a request is generally referred to as request evaluation.

The management policy rules can have the following implications for a request:

1. They can grant the right for the request to be executed.

2. If no rule grants the right for the request to be executed, then the request is denied.

3. The rules can specify that certain authentication workflows must be completed before the request may be executed.

4. The rules can specify that certain authorization workflows must be completed before the request may be executed.

5. The rules can specify that once the request has been executed, certain action workflows must be executed on the target.

6. The rules can specify that once the request has been executed, certain action workflows must be executed on resources other than the target. An action that is to be performed on a resource as a result of a request is generally referred to as a collateral action if the resource is not the target of the request.

The scope of a management policy rule is most commonly defined in terms of the set that the target of the request would join if the request was to be executed. For example, one might have a management policy rule that says that a certain action workflow is to be executed on the target of a request if the target will join the set of resources located at a certain address as a result of the request. Consequently, in order to determine which management policy rules may apply to a request, it is necessary to ascertain which sets the target will join if the request were to be executed. Since the request evaluation process must therefore determine at least some of the implications of the request on set membership, it has been given the task of calculating all of those implications.

The Scope of Management Policy Rules

Whether a management policy rule applies to a request depends on the scope of the rule. The scope of the rule a rule is controlled by several attributes:

1. The ActionType attribute: this attribute identifies an operation that may be requested. Other things being equal, a management policy rule applies to a request if the operation that is requested is one of those identified by the ActionType attribute of the rule.

2. The ActionParameter attribute: this attribute identifies an attribute of a resource to which a modification may be requested. Other things being equal, a management policy rule applies to a request if the attribute of a resource to which a modification is requested is one of those identified by the ActionParameter attribute of the rule.

3. The PrincipalSet attribute: this attribute of management policy rules identifies a set, and, other things being equal, a management policy rule applies to a request if the initiator of the request is a member of the set identified by the PrincipalSet attribute of the rule.

4. The PrincipalRelativeToResource attribute: this attribute of a management policy rule identifies an attribute of a resource. Other things being equal, a management policy rule applies to a request if it is true, for the target of the request, that the initiator of the request is identified by the value of the attribute specified by the rule's PrincipalRelativeToResource attribute. For example, if the value of the PrincipalRelativeToResource attribute is Manager for a management policy rule, X, then, other things being equal, the rule applies to any request that is initiated by a someone who is the manager of the target of the request. If a management policy rule has a PrincipalRelativeToResource attribute, then it cannot also have a PrincipalSet attribute.

5. The ResourceCurrentSet attribute: this attribute of a management policy rule identifies a set. Other things being equal, a management policy rule applies to a request if the target of the request currently belongs to the set identified by the management policy rule's ResourceCurrentSet attribute.

6. The ResourceCurrentRelativeToPrincipal attribute: this attribute of a management policy rule identifies an attribute of a resource. Other things being equal, a management policy rule applies to a request if it is true, for the initiator of the request, that the target of the request is identified by the value of the attribute specified by the rule's ResourceCurrentRelativeToPrincipal attribute. For example, if the value of the ResourceCurrentRelativeToPrincipal attribute is Assistant for a management policy rule, X, then, other things being equal, the rule applies to any request that is initiated by a someone whose assistant is the target of the request. If a management policy rule has a ResourceCurrentRelativeToPrincipal attribute, then it cannot also have a ResourceCurrentSet attribute.

7. The ResourceFinalSet attribute: this attribute of a management policy rule identifies a set. Other things being equal, a management policy rule applies to a request if, after the request has been processed, the target of the request will belong to the set identified by the management policy rule's ResourceCurrentSet attribute.

8. The ResourceFinalRelativeToPrincipal attribute: this attribute of a management policy rule identifies an attribute of a resource. Other things being equal, a management policy rule applies to a request if it will be true, for the initiator of the request, after the request has been processed, that the target of the request is identified by the value of the attribute specified by the rule's ResourceFinalRelativeToPrincipal attribute. For example, if the value of the ResourceFinalRelativeToPrincipal attribute is Assistant for a management policy rule, X, then, other things being equal, the rule applies to any request that is initiated by someone who is requesting a modification to their own data to make someone else their assistant. Other things being equal, the rule would also apply to any request that is initiated by someone whose current assistant is the target of the request, unless the request was to delete that resource, in which case, after the request has been processed, the target would no longer exist to be the assistant of the person who initiated the request. If a management policy rule has a ResourceFinalRelativeToPrincipal attribute, then it cannot also have a ResourceFinalSet attribute.

Rights

If someone makes a request, and that request is permitted according to the management policy rules, then, in the Microsoft Identity Lifecycle Manager argot, that person has the right to make that request. However, even if a person has the right to make a request, the management policy rules may require that other people authorize the request. In other words, the right to make a request is not always sufficient for the request to be authorized.

If a management policy rule applies to a request and the value of that rule's optional GrantsRight parameter is 1, then that rule grants the right for some or all of the requested modifications to be made. Specifically, the right is granted for the requested modifications to those attributes that are referred to by the ActionParameter attribute of the rule. If the ActionParameter attribute of the management policy rule only refers to one attribute, but the request is to modify several attributes, then, unless other management policy rules permit the requested modifications to those other attributes, the request is denied.

A Fifteenth-Century Dilbert Cartoon

2008-10-20T15:08:00Z

Reading Judith Barker's excellent Agincourt: Henry V and the Battle That Made England, I came across what is, in effect, an early fifteenth-century Dilbert cartoon. Barker, in discussing the strategic logistical planning for the Agincourt campaign, which Henry V of England undertook by invading France in the early 1400's, notes that gunpowder had been invented, and artillery had appeared on the battlefield. Early cannons, she explains, were not only difficult to aim, being very heavy metal things with no mechanical means of orienting them, but also required considerable effort merely to fire. The ammunition had to be loaded in the front, and a complicated, albeit primitive device, was used to get the gunpowder into the cannon. Consequently--and this is the crucial fact--the typical artillery crew usually only managed to fire their weapon once during a battle.

Now there is a record of a particularly efficient gunner, who, in a battle, was able to fire no less than an amazing three shots from his cannon in the course of a fight. Witnessing this feat, his commanders concluded that he could not have accomplished it were he not in league with the devil. So the gunner was sent off an a pilgrimage to cure his soul.

Microsoft Identity Lifecycle Manager "2:" What is it about Canadians and identity?

2008-10-01T22:07:00Z

A startling proportion of our team, including myself, are Canadians, either by birth, or, like me, by naturalization. Also, two of the products that Microsoft purchased and are now incorporated into Microsoft Identity Lifecycle Manager "2"--the synchronization engine that used to be marketed by itself as Microsoft Identity Integration Server 2003, and the smart card management solution acquired from Alacris--were both developed by Canadian companies. Alacris was based in the Canadian capital, Ottawa, which has always been a computer technology hub in that country--Corel is based there, and Cognos, among many other of the biggest software companies in the nation. The synchronization engine, my colleague Sorin Iftimie, another Canadian expatriate tells me, was born in Toronto. Anyhow, you can't toss a football down our corridors--as some folk have been known to do--without hitting at least a couple of hapless Canadians.

So what is that all about? Well, I recall that, at least when I was doing post-graduate studies in sociology at McMaster University in Hamilton, Ontario, Canada, in the late '80s and early '90s, there was much discussion about how Canadians lacked a common identity--anything substantive that they cherished together as Canadians, especially beliefs and aspirations. A notion that was already well-established at the time was that whereas the United States of America had been a melting pot of immigrants who came from diverse backgrounds but ended up practicing the same culture, Canada was a mosaic. At first glance, the largest distinct pieces of the mosaic would be English Canadians and French Canadians, but I believe it is true that among French-speaking Canadians, there are at least two distinct identities, that of the Quebecois, and that of the Acadians. Frankly, among English-speaking Canadians, it really is hard to discern a common sense of identity among them at all, except perhaps that of being huddled in the cold North, away from "the Americans," and generally being open and accepting to everyone except pedophiles (or at least those that don't respond well to treatment). Even an interest in ice hockey is not a given. My wife, who is a native-born east-coast Canadian, whose Canadian heritage extends further back than anyone in her family knows, has never watched a complete hockey game in her life--because hockey is just not a big deal where she comes from. (Hunting is another matter, although she hasn't shot anything either, except perhaps me, a few times, in fond daydreams.)

Anyhow ... here we have a team focused on the problem of identity and a ridiculous preponderance of Canadians working on it--people who, historically and culturally, have none, and feel the lack of it.