Stewardship and Accountability

I learned in this chapter that the Stephen Covey who wrote this book is the son of the Stephen Covey who wrote the popular Seven Habits book. In Seven Habits, the father tells the story of teaching his son to take care of his yard. In The Speed of Trust we get to hear that very son tell his side of the story. I enjoyed seeing this story from those different perspectives. The son’s main point was that when his father entrusted the keeping of the yard to him, that trust inspired him to become trustworthy. The main aspects of this story that I found instructive were:

• Clear stewardship. The father said the grass was to be kept “green and clean.” He showed in detail by example what both of those words meant.
• Defined accountability. The father explained that once a week they would walk through the yard together to see how well the son was keeping the yard green and clean.
• Autonomy of the “steward.” The father explained that the son was to use his own plan, his own timeline, his own resources, his own ideas to carry out his stewardship. The father didn’t give him detailed instructions, and wasn’t going to be reminding him and driving him to get the work done.
• Sufficient equipping. The father said he would be willing to help if the son needed it. It was clear that the son would need to ask for it, but all the resources of the father would be available to the son to be successful in his stewardship.
• Allowing failure. Things didn’t go perfectly right away; the son neglected his duties for a while. Yet the father honored the son’s autonomy by not nagging on him to get to work. The time of reckoning came, of course, at the agreed upon appointment when the accounting came. There were tears at this accounting, but the agreement continued, and the father dealt with things in a way that lead to the son learning how to keep the yard green and clean.
• Trust created trustworthiness. In this book, Covey’s primary emphasis was that when you entrust something to someone, just the very act of entrusting someone with the responsibility can inspire them to become more trustworthy. (Of course one can take this to naïve and foolish extremes.)

The story in the book that illustrates these things adds a lot of meaning to these points. I am going to try to put this into practice with my kids and their chores and schoolwork. At this point we are homeschooling our kids, and a few of them wear their mother out because she has to keep riding them to keep on their work. I think a system like this may help – to tell them, “It’s no longer your mother’s job to make sure you get your work done. It’s your job. And every other evening you have an appointment with me, where you will give an account of where your schoolwork and chores are at.”

Trust = Character + Competence

It seems very true to me. When we trust someone in a particular circumstance, we have to trust both their character and their competence. Other ways to describes these are integrity and intelligence; personal trust and expertise trust; heart and head.

Consider that a person can be a wonderfully nice and honest person who never breaks the most minute law, always holds doors for ladies and helps the elderly. But if that person is not a very good carpenter, you’re not going to trust him to build the shed in your back yard. For specific circumstances, character is not enough; competence is necessary.

The reverse is certainly true: you can have the most proficient carpenter in the world, but if he’s a liar and a cheat and has a dangerous temper, you’re not going to want to work with him, either.

I found the examination of the two facets of trust to be very clarifying to my own thinking.

Yet one more way that the world is slowed down because of the number of people who aren’t trustworthy.

Corporate Application

Consider the example of Warren Buffet when acquiring McLane Distribution from Wal-Mart. Such a merger typically takes months, with several million dollars for accountants, auditors, and attorneys. The two parties in the case trusted one another; the deal was made with a two-hour meeting, and completed in less than a month. I find Warren Buffett’s words from his 2004 annual report to be very powerful: “We did no ‘due diligence.’ We knew everything would be exact as Wal-Mart said it would be – and it was.”

On the other hand, the incredible cost large companies face of implementing the Sarbanes-Oxley can be attributed to the distrust created by Enron and WorldCom.

Individual Application

The speed of trust is not just for the corporate world. The book suggests that the “office politics” that people hate are usually extra overhead created because people distrust one another.

When describing what trust is, as Covey sees it, he writes that trust is confidence; it’s the opposite of suspicion. When you trust someone, you have confidence in their integrity and abilities. When you distrust someone, you are suspicious of their integrity, agenda, capabilities or their track record. Working with someone you trust is often joyful and efficient; working with someone you distrust is draining, tedious and cumbersome.

My own example: consider even simply going on a camping and fishing trip with someone you have confidence in: you believe they are trustworthy to bring ample supplies; you have confidence in their abilities to be able to help efficiently with all the little duties needed to have a fun and successful trip. How much less would you enjoy a trip like that with someone who you didn’t have confidence in?

“Doug”

I thought it was a surprising coincidence that after reading this chapter I heard a couple more stories in a different context that related to this.

I heard second-hand the story of a successful businessman in the Fargo area. His family has owned a grain elevator for years in the past. When a farmer brings his grain in, an elevator worker scoops a handful of grain out to sample it for chaff and moisture content; the value of the grain depends on the sample. Elevator owners know that the shape they hold their hand in as they scoop up the grain makes a difference in the amount of chaff picked up. There’s a big temptation for owners to pick up as much chaff as they can, and thereby pay less for the grain. When this man’s father taught him to do it, he said, “You hold your hand like this, to get the best possible price for the farmer. The reason, Doug, is that our customers must trust us.”

Later in this man’s life, when his software business was growing but still struggling, this life-lesson of trust was tested. The company had shipped out software with a major bug. The timing couldn’t have been worse: the nation-wide (world-wide?) convention was imminent.

Of course the buzz of the convention was angry customers complaining about the issue. Doug took a huge risk, putting the company on the line. During a talk of the convention he said, “We messed up. We’re working hard to fix it. We know this is costing you money. I can’t make any promises, but send us a bill for the expense we’ve cost you.” This was very risky because the company at this time wasn’t flush with cash. But suddenly so much of the trust (confidence) that had been lost in this company was turned around. The tone of conversations at the convention changed dramatically.

Here’s where the speed of trust hits hard: Out of the hundreds of customers that were invited to send bills, only two did. I suppose this indicates that the customers weren’t as concerned about the money loss as they were the lack of confidence they had in the company, and when Doug acknowledged the mix-up and was willing to go to such lengths to make it right, the trust and confidence was restored.

Looking forward to the rest of the book

Covey talks about how earning and keeping trust sometimes has to be a deliberate effort; you don’t get it by default. People with whom you don’t often interact, by default will doubt you. Covey talks about proactively establishing and increasing trust. I’m excited to learn what he has to say about doing that; hopefully the techniques aren’t ways to fake trustworthiness, but simply ways to express whether you are trustworthy or not. I’m excited about how the ideas in this book might improve relationships in every area of my life.

Link to The Speed of Trust on Amazon.

alter database DbName
    set single_user
    with rollback immediate
go

restore database DbName
    from disk = 'path/to/backup.bak'
    with file = 1, replace

Notables:

• Works best to run against the master database.
• The file = 1 part may need to be changed if there are multiple backups in the file and the one you want isn’t the first one.

I found the obscurity of the Send button annoying. “There’s got to be a better way to do that,” thought I. Pull up Gmail – no problem finding it. A much smarter UX design. A breath of fresh air, even.

Microsoft seems to really struggle with getting good UX, and it kills me. It’s like being a Minnesota Vikings fan – I really want them to do well, but even when they’ve got something good going, and put together a really awesome thing, they always seem to snatch defeat from the jaws of victory. My wife doesn’t use a Windows Phone because of some very specific UX decisions Microsoft made poorly (see “aside” below). I suspect the reason Microsoft can’t get UX right has to do with this image being a little too true: http://www.bonkersworld.net/organizational-charts/

A culture of militant fragmentation manifests itself in their products; their UI’s come out fragmented rather than cohesive. It’s hard to sort out political power plays from earnest pursuit of excellence, so stuff that really should get done gets blocked. And it’s been going on for a loooong time (eg, how far buried ClearType was in Windows XP).

I know there are folks within Microsoft trying to change this. Here’s wishing for the best to them and to the Vikings.

—

Aside: the Windows Phone UX disaster was that to save a phone number on a new contact, you had to first click “Ok” for the phone number, then click “Save” on the contact. The second step shouldn’t have ever been there. Steve Jobs would have found it before the phone ever released, fired the person who put it in there, and it never would have seen the light of day. Thankfully Microsoft fixed this UX travesty in Mango, but they created an Apple fan in my wife – she returned her Windows Phone and loves her iPhone now.

So there are several nuget packages for libraries to help with this. I chose NDesk.Options and I liked it. Here’s what your command-line argument code might look if you used this library.

public class MyProgramSettings {

    public string InputFile { get; set; }
    public string ErrorFile { get; set; }
    public string OutputFile { get; set; }
    public bool ShowStackTrace { get; set; }

}

public static Main(string[] args) {
    var settings = new MyProgramSettings();
    var showHelp = false;

    var parser = new NDesk.Options.OptionSet() {
        { "h|?|help",  "Show available options",       v => showHelp = true },
        { "i=|input",  "The name of the input file.",  v => settings.InputFile = v },
        { "e=|error",  "The name file to log errors.", v => settings.ErrorFile = v },
        { "o=|output", "The name of the output file.", v => settings.OutputFile = v },
        { "s|stack ",  "Show stack traces.",           v => settings.ShowStackTrace = true }
    };

    parser.Parse(args);
    if(showHelp) {
        parser.WriteOptionDescriptions(Console.Out);
    }
}

[Reflection.Assembly]::LoadWithPartialName("System.Messaging");

$queueName = '.\Private$\your.queue.name';
$queue = new-object System.Messaging.MessageQueue $queueName;
$utf8 = new-object System.Text.UTF8Encoding;

$tran = new-object System.Messaging.MessageQueueTransaction;
$tran.Begin();

$msgContent = '<?xml version="1.0" ?>
    <Messages xmlns="your-xml-namespace">
        <IWebApplicationStartupCompleting>
        </IWebApplicationStartupCompleting>
    </Messages>';
$msgBytes = $utf8.GetBytes($msgContent);

$msgStream = new-object System.IO.MemoryStream;
$msgStream.Write($msgBytes, 0, $msgBytes.Length);

$msg = new-object System.Messaging.Message;
$msg.BodyStream = $msgStream;
$queue.Send($msg, $tran);

$tran.Commit();

[Reflection.Assembly]::LoadWithPartialName("System.Messaging")

$queueName = '.\Private$\your.queue.name\Journal$';
$queue = new-object System.Messaging.MessageQueue $queueName;
$utf8 = new-object System.Text.UTF8Encoding;

$msgs = $queue.GetAllMessages();
$msgs | %{
    write-host $_.Id;
    write-host $utf8.GetString($_.BodyStream.ToArray());
};

Code that looks right, but is wrong:

There are a few workarounds; the one Douglas Crockford recommends is to create a new variable (conventionally named “that”) referenced by the inner function.

The “that” convention is fitting because you’re saying, “It’s not the close-by this, it’s that ‘this’ from over there.” Kinda cute.

Incidentally, CoffeeScript has a construct to compensate for the confusing (although very logical) behavior of this in JavaScript. I like CoffeeScript; been playing with it in a side project and hope to use it for a Javascript-heavy green-field project soon.

Bottom Line: with JavaScript, when you have a function defined inside of another function, “this” in the inner function might not be what you expect.

I wanted to know how to get the list of parameters for a stored procedure programmatically. I typed in my search terms and here’s ddg’s response. What blew me away was that it pulled the exact answer to my question from stack overflow and put it at the top of the result list:

Cool. I could say it saved me a bunch of time, but it prompted me to write this blog post, so that’s not true this time.