On Sept. 10, 2015, Winston Kodogo writes:

Hey Chris, if you’re feeling happy enough to blog, how about a post giving us your current thoughts on UI development. A friend of mine has asked me for advice on moving an in-house app from VB6 to something he can find people to modify if he needs to, and I can’t for the life of me think of what to tell him. I have your most excellent books on Windows Forms and WPF, but what would the modern (!) equivalent be. Not WebJS, surely.

Thanks for the softball question, Winston. I do love to pontificate extemporaneously (although I have already given away the ending).

Pre-Windows

I started my Windows career as a Petzoldian Windows developer, but before that, I developed UIs in curses, Flavors Lisp and even voice-based UIs in a proprietary AT&T scripting language for which I no longer remember the name.

Windows

As a Windows developer, I programmed against 16 and 32-bit GDI and User, GDI+, MFC, WTL, Windows Forms, WPF, WinJS, Silverlight and Xamarin Forms. I’ve even written books, articles and presentations about many of these toolkits.

And even now, as I type this, I’m using a different framework, Markdown, to produce the UI you’re using now.

Transcend Windows

It’s this last fact that leads me to my pretty much universal recommendation for UI development: The UI framework with the most reach, the best tools, the most community support and the best staying power is, of course, HTML, with it’s kissing cousins, JavaScript and CSS.

There are good reasons to choose others, of course:

• Are you building a desktop game? Use OpenGL or DirectX.

• Are you building a mobile game? Use the iOS or Android APIs or, even better, Unity.

• Do you love C# and .NET? Then some implementation of XAML may suit your needs.

• Are you targeting developers with automation or specific integration needs? Then a command line interface is probably what you want.

But other than that, my default UI development advice is always always HTML.

HTML How

The beauty of an HTML-based UI framework is that it has grown steadily in capability, usage and ubiquity since it was introduced in 1993. It’s hard to find an environment where HTML doesn’t run:

• Desktop Browser: This is where HTML was first shown and it arguably shows best here. There’s little you can’t do in this environment, including near native games using WebGL, Enscripten and asm.js (soon to become WebAssembly).

  This is probably your best bet for any kind of internal app, e.g. the kind of thing that VB6 and WinForms are usually used for. Toolkits like Angular and React are popular for desktop browser apps because they provide the end-to-end developer story while still having rich extension libraries.

  That said, if I were going to tackle a new web site or web app today, I’d probably use WebComponents (and Polymer) for the excellent reasons that Joe Gregorio lays out in his OSCON 2015 talk.

• Mobile Browser: Today’s smartphone-based browsers are very capable and adapt to desktop-based web sites fairly well. However, I do recommend making sure your desktop web sites work well on mobile as well, if for no other reason than you want to make sure you don’t lose your ranking on Google, which now prefers mobile-friendly sites for mobile search results (and provides a tool to help you get your site ready).

  With the modern enterprise moving towards mobile as fast now as they have been moving towards the web-based intranet over the last decade, I’d recommend making sure that your internal web sites/apps work well on mobile if you want to avoid the CTO stopping by your desk in the near future.

• Desktop Stand-alone App: The new trend (with companies like GitHub and Microsoft on board) for building cross-platform, stand-alone desktop apps is to use HTML, but package it into an app, specifically using something like Electron. This is the new hotness, but this is what I’d do if I wanted to build a stand-alone desktop app today.

• Mobile Store App: Most mobile apps today are built for the iOS and Google Play stores, although increasingly enterprises are building mobile apps for internal use and distributing them internally using private stores like Appaloosa.

  Today, mobile apps are built overwelminging using the platform-specific native APIs, most often with two separate teams for each app, one for iOS and one for Android. However, as mobile becomes more of an enterprise platform, you want apps that are developed quickly, can be maintained easily and can be built with a smaller number of developers, which all boils down to one thing: you want to have a single codebase for your internal mobile apps instead of one codebase per platform.

  Today, you have two viable alternatives when building mobile apps that target multiple platforms from a single source code base: Xamarin and Adobe PhoneGap. Xamarin is essentially cross-platform .NET with some UI controls and native compilation thrown in, whereas PhoneGap is a framework for hosting HTML on mobile platforms (as well as others, but no one does that) along with a platform-agnostic JavaScript API that maps to native functionality.

  I’ve used both of these frameworks and they both have their pros and cons. Xamarin has a simple UI framework that changes it’s look ’n’ feel depending on the platform your app is running on, but PhoneGap does not. In that case, I’d also bring Ionic into the mix, which will let you write your app in HTML but give you the native UI as appropriate (and a beautiful one at that).

  There has been much said about whether HTML is appropriate for building mobile apps and while it’s possible to build a bad app using any platform, in my experience, it’s not hard to get an app that’s built in HTML to look ’n’ feel just like a native app. When I did it, there were some tricks involved, but frameworks like Ionic pretty much take away the need for that these days. Of course there are always going to be apps that can’t be built this way, but as a percentage (leaving out twitch games), that number is getting smaller and smaller.

Where are we?

Of course, the best and worst part of the web platform is that the community changes it’s mind about how sites and apps should be built for the web platform about as often as I change my underwear, so the specific recommendations are merely appropriate for this point in time. The general guidance remains the same, however: choose HTML for your UI development unless you’ve got a darn good reason not to.

By default, Xamarin.Forms handles orientation changes for you automatically, e.g.

Xamarin.Forms handles orientation changes automatically

In this example, the labels are above the text entries in both the portrait and the landscape orientation, which Xamarin.Forms can do without any help from me. However, what if I want to put the labels to the left of the text entries in landscape mode to take better advantage of the space? Further, in the general case, you may want to have different layouts for each orientation. To be able to do that, you need to be able to detect the device’s current orientation and get a notification when it changes. Unfortunately, Xamarin.Forms provides neither, but luckily it’s not hard for you to do it yourself.

Finding the Current Orientation

To determine whether you’re in portrait or landscape mode is pretty easy:

static bool IsPortrait(Page p) { return p.Width < p.Height; }

This function makes the assumption that portrait mode has a smaller width. This doesn’t work for all future imaginable devices, of course, but in the case of a square device, you’ll just have to take your changes I guess.

Orientation Change Notifications

Likewise, Xamarin.Forms doesn’t have any kind of a OrientationChanged event, but I find that handling SizeChanged does the trick just as well:

SizeChanged += (sender, e) => Content = IsPortrait(this) ? portraitView : landscapeView;

The SizeChanged event seems to get called exactly once as the user goes from portrait to landscape mode (at least in my debugging, that was true). The different layouts can be whatever you want them to be. I was able to use this technique and get myself a little extra vertical space in my landscape layout:

Using a custom layout to put the labels on the left of the text entries instead of on top 

Of course, I could use this technique to do something completely differently in each orientation, but I was hoping that the two layouts made sense to the user and didn’t even register as special, which Xamarin.Forms allowed me to do.

My goal was to take the name and address of a place and show it on the native map app regardless of what mobile platform on which my app was running. While Xamarin.Forms provides a cross-platform API to launch the URL that starts the map app, the URL format is different depending on whether you’re using the Windows Phone 8 URI scheme for Bing maps, the Android Data URI scheme for the map intent or the Apple URL scheme for maps.

This is what I came up with:

public class Place {
  public string Name { get; set; }
  public string Vicinity { get; set; }
  public Geocode Location { get; set; }
  public Uri Icon { get; set; }
}
public void LaunchMapApp(Place place) {
  // Windows Phone doesn't like ampersands in the names and the normal URI escaping doesn't help
  var name = place.Name.Replace("&", "and"); // var name = Uri.EscapeUriString(place.Name);
  var loc = string.Format("{0},{1}", place.Location.Latitude, place.Location.Longitude);
  var addr = Uri.EscapeUriString(place.Vicinity);

  var request = Device.OnPlatform(
    // iOS doesn't like %s or spaces in their URLs, so manually replace spaces with +s
    string.Format("http://maps.apple.com/maps?q={0}&sll={1}", name.Replace(' ', '+'), loc),

    // pass the address to Android if we have it
    string.Format("geo:0,0?q={0}({1})", string.IsNullOrWhiteSpace(addr) ? loc : addr, name),

    // WinPhone
    string.Format("bingmaps:?cp={0}&q={1}", loc, name)
  );

  Device.OpenUri(new Uri(request));
}

This code was testing on several phone and tablet emulators and on 5 actual devices: an iPad running iOS 8, an iPad Touch running iOS 8, a Nokia Lumia 920 running Windows Phone 8.1, an LG G3 running Android 4.4 and an XO tablet running Android 4.1. As you can tell, each platform has not only it’s own URI format for launching the map app, but quirks as well. However, this code works well across platforms. Enjoy.

Settings allow you to separate the parameters that configure the behavior of your app separate from the code, which allows you to change that behavior without rebuilding the app. This is handle at the app level for things like server addresses and API keys and at the user level for things like restoring the last user input and theme preferences. Xamarin.Forms provides direct support for neither, but that doesn’t mean you can’t easily add it yourself.

App Settings

Xamarin.Forms doesn’t have any concept of the .NET standard app.config. However, it’s easy enough to add the equivalent using embedded resources and the XML parser. For example, I built a Xamarin.Forms app for finding spots for coffee, food and drinks between where I am and where my friend is (MiddleMeeter, on GitHub). I’m using the Google APIs to do a bunch of geolocation-related stuff, so I need a Google API key, which I don’t want to publish on GitHub. The easy way to make that happen is to drop the API key into a separate file that’s loaded at run-time but to not check that file into GitHub by adding it to .gitignore. To make it easy to read, I added this file as an Embedded Resource in XML format:

Adding an XML file as an embedded resource makes it easy to read at run-time for app settings

I could’ve gone all the way and re-implemented the entire .NET configuration API, but that seemed like overkill, so I kept the file format simple:

<?xml version="1.0" encoding="utf-8" ?>
<config>
  <google-api-key>YourGoogleApiKeyHere</google-api-key>
</config>

Loading the file at run-time uses the normal .NET resources API:

string GetGoogleApiKey() {
  var type = this.GetType();
  var resource = type.Namespace + "." +
    Device.OnPlatform("iOS", "Droid", "WinPhone") + ".config.xml";
  using (var stream = type.Assembly.GetManifestResourceStream(resource))
  using (var reader = new StreamReader(stream)) {
    var doc = XDocument.Parse(reader.ReadToEnd());
    return doc.Element("config").Element("google-api-key").Value;
  }
}

I used XML as the file format not because I’m in love with XML (although it does the job well enough for things like this), but because LINQ to XML is baked right into Xamarin. I could’ve used JSON, too, of course, but that requires an extra NuGet package. Also, I could’ve abstracting things a bit to make an easy API for more than one config entry, but I’ll leave that for enterprising readers.

User Settings

While app settings are read-only, user settings are read-write and each of the supported Xamarin platforms has their own place to store settings, e.g. .NET developers will likely have heard of Isolated Storage. Unfortunately, Xamarin provides no built-in support for abstracting away the platform specifics of user settings. Luckily, James Montemagno has. In his Settings Plugin NuGet package, he makes it super easy to read and write user settings. For example, in my app, I pull in the previously stored user settings when I’m creating the data model for the view on my app’s first page:

class SearchModel : INotifyPropertyChanged {
  string yourLocation;
  // reading values saved during the last session (or setting defaults)
  string theirLocation = CrossSettings.Current.GetValueOrDefault("theirLocation", "");
  SearchMode mode = CrossSettings.Current.GetValueOrDefault("mode", SearchMode.food);
  ...
}

The beauty of James’s API is that it’s concise (only one function to call to get a value or set a default if the value is missing) and type-safe, e.g. notice the use of a string and an enum here. He handles the specifics of reading from the correct underlying storage mechanism based on the platform, translating it into my native type system and I just get to write my code w/o worrying about it. Writing is just as easy:

async void button1_Clicked(object sender, EventArgs e) {
  ...

  // writing settings values at an appropriate time
  CrossSettings.Current.AddOrUpdateValue("theirLocation", model.TheirLocation);
  CrossSettings.Current.AddOrUpdateValue("mode", model.Mode);

  ...
}

My one quibble is that I wish the functions were called Read/Write or Get/Set instead of GetValueOrDefault/AddOrUpdateValue, but James’s function names make it very clear what’s actually happening under the covers. Certainly the functionality makes it more than worth the extra characters.

User Settings UI

Of course, when it comes to building a UI for editing user settings at run-time, Xamarin.Forms has all kinds of wonderful facilities, including a TableView intent specifically for settings (TableIntent.Settings). However, when it comes to extending the platform-specific Settings app, you’re on your own. That’s not such a big deal, however, since only iOS actually supports extending the Settings app (using iOS Settings Bundles). Android doesn’t support it at all (they only let the user configure things like whether an app has permission to send notifications) and while Windows Phone 8 has an extensible Settings Hub for their apps, it’s a hack if you do it with your own apps (and unlikely to make it past the Windows Store police).

Where Are We?

So, while Xamarin.Forms doesn’t provide any built in support for app or user settings, the underlying platform provides enough to make implementing the former trivial and the Xamarin ecosystem provides nicely for the latter (thanks, James!).

Even more interesting is what Xamarin has enabled with this ecosystem. They’ve mixed their very impressive core .NET and C# compiler implementation (Mono) with a set of mobile libraries providing direct access to the native platforms (MonoTouch and MonoDroid), added a core implementation of UI abstraction (Xamarin.Forms) and integration into the .NET developer’s IDE of choice (Visual Studio) together with an extensible, discoverable set of libraries (NuGet) that make it easy for 3rd party developers to contribute. That’s a platform, my friends, and it’s separate from the one that Microsoft is building. What makes it impressive is that it takes the army of .NET developers and points them at the current hotness, i.e. building iOS and Android apps, in a way that Microsoft never could. Moreover, because they’ve managed to also support Windows Phone pretty seamlessly, they’ve managed to get Microsoft to back them.

We’ll see how successful Xamarin is over time, but they certainly have a very good story to tell .NET developers.

In 1992, I was a Unix programmer in Minneapolis. I’d graduated with a BS in Computer Science from the University of MN a year earlier and had written my programming assignments in C and C++ via first a VT100 terminal and then a VT100 terminal emulator on my Mac (running System 7, if you’re curious). My day job was at an AT&T VAR building multi-user voice response systems on Unix System V. My favorite editor was vi (not vim) and, like all good vi programmers, I hated emacs with a white hot passion.

Being bored with my current job, I posted my resume on the internet, which meant uploading it in ASCII text to an FTP site where tech companies knew to look for it. The tech company that found it was Intel. To prepare for my interview in Portland, OR, I went to play with a Windows 3.1 machine that someone had set up in the office, but nobody used. I had a Mac at home and Unix at work and for the 10 minutes that I could stand to use it, Windows 3.1 seemed like the worst of both. In spite of my distaste, Intel made an offer I couldn’t refuse and I found myself moving with my new wife to a new city for a new job and a new technology stack.

The move to Intel started my love affair with Windows (starting with Windows 95, of course, let’s be reasonable). Over the years, I grew to love Word, Excel, Visio, PowerPoint, Outlook, Live Writer, Skype, Windows XP, Windows 7, COM, ATL, .NET, C# and of course the Big Daddy for Windows developers: Visual Studio. Not only did I become a Windows fan boy (I can’t tell you how lonely it is to own a Windows Phone after the iPhone was released), but I became I contributing member of the Windows community, accounting for nearly 100% of the content on this web site, first published in 1995 solely to provide links to my DevelopMentor students, but growly steadily since (over 2600 posts in 20 years). Add to that to more than a dozen books and countless public speaking engagements, magazine articles and internet appearances and you’ve got a large investment in the Windows technology stack.

Of course, as I take on roles beyond consultant, speaker, author and community PM, I contribute less and less (although I do love spouting off into my twitter feed). Even so, I’ve been a regular attendee to Windows-related events and 90% of my friends are also Windows developers, so the idea of leaving not just a technology ecosystem but an entire community behind is a pretty daunting one.

And then, about 45 days ago, Google came knocking with an offer I couldn’t refuse. A few days after that, before I’ve even officially accepted the offer, I find myself in a bidding war for a house in Kirkland, WA that the wife and I both love (which almost never happens). So, for the first time since 1992, with my three boys graduated from high school, I find myself moving with my new wife to a new city for a new job and a new technology stack. As I write this, it’s the Friday before my Noogler orientation week (New Googler — get it?). I’ll be working on tools for Google cloud developers, which matches my Windows experience helping developers build distributed systems, although there’s going to be a huge learning curve swapping in the details.

After 20 years with Visual Studio, I don’t know if my fingers still know vi, but I can’t wait to find out. If I get a beer or two in me, I might even give emacs another try…

In 30 years, I’ve done a lot of interviewing from both sides of the table. Because of my chosen profession, my interviewing has been for technical positions, e.g. designers, QA, support, docs, etc., but mostly for developers and program managers, both of which need to understand a system at the code level (actually, I think VPs and CTOs need to understand a system at the code level, too, but the interview process for those kinds of people is a superset of what I’ll be discussing in this series).

In this discussion, I’m going to assume you’ve got a team doing the interview, not just a person. Technical people need to work well in teams and you should have 3-4 people in the interview cycle when you’re picking someone to join the team.

The Most Important Thing!

Let me state another assumption: you care about building your team as much as you care about building your products. Apps come and go, but a functional team is something you want to cherish forever (if you can). If you just want to hire someone to fill a chair, then what I’m about to describe is not for you.

The principle I pull from this assumption is this: it’s better to let a good candidate go then to hire a bad one.

A bad hire can do more harm than a good hire can repair. Turning down a “pretty good” candidate is the hardest part of any good interview process, but this one principle is going to save you more heartache than any other.

The Phone Screen

So, with these assumptions in mind, the first thing you always want to do when you’ve got a candidate is to have someone you trust do a quick phone screen, e.g. 30 minutes. This can be an HR person or someone that knows the culture of the company and the kind of people you’re looking for. A phone screen has only one goal: to avoid wasting the team’s time. If there’s anything that’s an obvious mismatch, e.g. you require real web development experience, but the phone screen reveals that the candidate really doesn’t, then you say “thanks very much” and move on to the next person.

If it’s hard to get a person to come into your office — maybe they’re in a different city — you’ll also want to add another 30 minutes to do a technical phone screen, too, e.g.

• Describe the last app they built with Angular.
• Tell me how JVM garbage collection works.
• What’s the right data structure to hold the possible solutions to tic-tac-toe?

Whatever it is, you want to make reasonably sure that they’re going to be able to keep up with their duties technically before you bring them on site, or you’re just wasting the team’s time.

At this point, if you’re hiring a contractor, you may be done. Contractors are generally easy to fire, so you can bring them on and let them go easily. Some companies start all of their technical hires as contractors first for a period of 30-90 days and only hire them if that works out.

If you’re interviewing for an FTE position, once they’ve passed the phone screen, you’re going to bring them into the office.

You should take a candidate visit seriously; you’re looking for a new family member. Even before they show up, you make sure you have a representative sample of the team in the candidate’s interview schedule. At the very least, you need to make sure that you have someone to drill into their technical abilities, someone to deal with their ability to deliver as part of a team and someone to make sure that they’re going to be a cultural fit with the company as a whole. Each of these interview types is different and deserves it’s own description.

Future Posts in This Series

Tune in to future posts in this series where we’ll be discussing:

• The Technical Interview
• The Fit Interviews
• Hiring or Not

I’m surprised how well that my commentRss proposal has been accepted in the world. As often as not, if I’m digging through an RSS feed for a site that supports comments, that site also provides a commentRss element for each item. When I proposed this element, my thinking was that I could make a comment on an item of interest, then check a box and I’d see async replies in my RSS client, thereby fostering discussion. Unfortunately, RSS clients never took the step of allowing me to subscribe to comments for a particular item and a standard protocol for adding a comment never emerged, which made it even less likely for RSS clients to add that check box. All in all, commentRss is a failed experiment.

Fostering Discussion in Blog Post Comments

However, the idea of posting comments to a blog post and subscribing to replies took off in another way. For example, Facebook does a very good job in fostering discussion on content posted to their site:

The Facebook supports comments and discussions nicely

Not only does Facebook provide a nice UI for comments, but as I reply to comments that others have made, they’re notified. In fact, as I was taking the screenshot above, I replied to Craig’s comment and within a minute he’d pressed the Like button, all because of the support Facebook has for reply notification.

However, Facebook commenting only works for Facebook content. I want the same kind of experience with my own site’s content. For a long time, I had my own custom commenting system, but the bulk of the functionality was around keeping spam down, which was a huge problem. I recently dumped my comments to an XML format and of the 60MB of output, less than 8MB were actual comments — more than 80% was comment spam. I tried added reCAPTCHA and eventually email approval of all comments, but none of that fostered the back-and-forth discussions over time because I didn’t have notifications. Of course, to implement notifications, you need user accounts with email verification, which was a whole other set of features that I just never got around to implementing. And even if I did, I would have taken me a lot more effort to get to the level of quality that Disqus provides.

Integrating Disqus Into Your Web Site

Disqus provides a service that lets me import, export and manage comments for my site’s blog posts, the UI for my web site to collect and display comments and the notification system that fosters discussions. And they watch for spam, too. Here’s what it looks like on a recent post on my site:

The Disqus services provides a discussion UI for your web site

Not only does Disqus provide the UI for comments, but it also provides the account management so that commenters can have icons and get notifications. With the settings to allow for guest posting, the barrier to entry for the reader that wants to leave a comment is zero. Adding the code to enable it on your site isn’t zero, but it’s pretty close. Once you’ve established a free account on disqus.com, you can simply create a forum for your site and drop in some boilerplate code. Here’s what I added to my MVC view for a post’s detail page to get the discussion section above:

<%-- Details.aspx –%>

...
<asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">
  <!-- post –>
  ...

  <h1><%= Model.Post.Title %></h1>
  <div><%= Model.Post.Content %></div>
  <!-- comments -->
  <div id="disqus_thread"></div>
  <script type="text/javascript">
    var disqus_shortname = "YOUR-DISQUS-SITE-SHORTNAME-HERE";
    var disqus_identifier = <%= Model.Post.Id %>;
    var disqus_title = "<%= Model.Post.Title %>";

    /* * * DON'T EDIT BELOW THIS LINE * * */
    (function () {
      var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true;
      dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
      (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
    })();
  </script>
</asp:Content>

The discussion section for any post is just a div with the id set to “disqus_thread”. The code is from the useful-but-difficult-to-find Disqus universal embed code docs. The JavaScript added to the end of the page creates a Disqus discussion control in the div you provide using the JS variables defined at the top of the code. The only JS variable that’s required is the disqus_shortname, which defines the Disqus data source for your comments. The disqus_identifier is a unique ID associated with the post. If this isn’t provided, the URL for the page the browser is currently showing will be used, but that doesn’t work for development mode from localhost or if the comments are hosted on multiple sites, e.g. a staging server and a production server, so I recommend setting disqus_identifier explicitly. The disqus_title will likewise be taken from the current page’s title, but it’s better to set it yourself to make sure it’s what you want.

And that’s it. Instead of tuning your UI in the JS code, you do so in the settings on disqus.com yourself an includes things like the default order of comments, the color scheme, how much moderation you want, etc.

There’s one more page on your site where you’ll want to integrate Disqus: the page the provides the list of posts along with the comment link and comment count:

Disqus will add comment count to your comment lists, too

Adding support for the comment count is similar to adding support for the discussion itself:

<%-- Index.aspx --%>
...

<asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">
  ...

  <!-- post -->
  <h2><%= Html.ActionLink(post.Title, "Details", "Posts", new { id = post.Id }, null) %></h2>
  <p><%= post.Content %></p>
  <!-- comment link --> 

  <p><%= Html.ActionLink("0 comments", "Details", "Posts", null, null, "disqus_thread",
           new RouteValueDictionary(
             new { id = post.Id }),
             new Dictionary<string, object>() { { "data-disqus-identifier", post.Id } }) %></p>
  ...

  <script type="text/javascript">
    // from: https://help.disqus.com/customer/portal/articles/565624
    var disqus_shortname = "sellsbrothers";

    /* * * DON'T EDIT BELOW THIS LINE * * */
    (function () {
      var s = document.createElement('script'); s.async = true;
      s.type = 'text/javascript';
      s.src = 'http://' + disqus_shortname + '.disqus.com/count.js';
      (document.getElementsByTagName('HEAD')[0] || document.getElementsByTagName('BODY')[0]).appendChild(s);
    }());
  </script>
</asp:Content>

Again, this code is largely boilerplate and comes from the Disqus comment count docs. The call to Html.ActionLink is just a fancy way to get an A tag with an href of the following format:

>#disqus_thread” data-disqus-identifier=“<>”>0 comments

The “disqus_thread” tag at the end of the href does two things. The first is that it provides a link to the discussion portion of the details page so that the reader can scroll directly to the comments after reading the post. The second is that it provides a tag for the Disqus JavaScript code to change the text content of the A tag to show the number of comments.

The “data-disqus-identifier” attribute sets the unique identifier for the post itself, just like the disqus_identifier JS variable we saw earlier.

The A tag text content that you provide will only be shown if Disqus does not yet know about that particular post, i.e. if there are no comments yet, then it will leave it alone. However, if Disqus does know about that post, it will replace the text content of the A tag as per your settings, which allow you to be specific about how you want 0, 1 and n comments to show up on your site; “0 comments”, “1 comment” and “{num} comments” are the defaults.

Importing Existing Comments into Disqus

At this point, your site is fully enabled for Disqus discussions and you can deploy. In the meantime, if you’ve got existing comments like I did, you can import them using Disqus’s implementation of the WordPress WXR format, which is essentially RSS 2.0 with embedded comments. The Disqus XML import docs describe the format and some important reminders. The two reminders they list are important enough to list again here:

• “Register a test forum and import to that forum first to work out the kinks.” Because Disqus only lists some of the restrictions on their site for the imported data, I probably had to do a dozen or more imports before I get everything to move over smoothly. I ended up using two test forums before I was confident enough to import comments into my the real forum for my site.
• “Keep individual file sizes < 50 MB each.” In fact, I found 20MB to be the maximum reliable size. I had to write my script to split my comments across multiple files to keep to this limit or my uploads would time out.

The XML import docs do a good job showing what the XML format is as an example, but they only list one of the data size requirements. In my work, I found several undocumented limits as well:

• comment_content must be >= 3 characters (space trimmed) and <= 25,000 characters. I found out the max when trying to import some of my unapproved spam comments.
• comment_author and comment_author_email must be <= 75 characters. You may get errors about comment_author being too long even if you haven’t provided one; that just means that Disqus has grabbed comment_author_email as the contents for comment_author.
• post_date_gmt and comment_date_gmt must be formatted correctly as yyyy-MM-dd HH:mm:ss. Of course, they must be in GMT, too.
• The actual post content should be empty. Even though it looks like you’re uploading your entire blog via RSS, you’re only providing enough of the post content to allow Disqus to map from post to associated comments, like the thread_identifier referenced as disqus_thread in the JavaScript code above, as well as to show the post title and date as appropriate. The only real content you’re importing into Disqus is the comment content associated with each post.

Something else to keep in mind is that as part of the comment import process is that Disqus translates the XML data into JSON data, which makes sense. However, they report their errors in terms of the undocumented JSON data structure, which can be confusing as hell. For example, I kept getting a “missing or invalid message” error message along with the JSON version of what I thought the message was to which they were referring. The problem was that by “message”, Disqus didn’t mean “the JSON data packet for a particular comment,” they meant “the field called ‘message’ in our undocumented JSON format which is mapped from the comment_content element of the XML.” I went round and round with support on this until I figured that out. Hopefully I’ve saved future generations that trouble.

If you’re a fan of LINQPad or C#, you can see the script I used to pull the posts and comments out of my site’s SQL Server database (this assumes an Entity Framework mapping in a separate DLL, but you get the gist). The restrictions I mention above are encapsulated in this script.

Where Are We?

Even though my rssComments extension to the RSS protocol was a failed experiment, the web has figured out how to foster spam-free, interactive discussions with email notifications across web sites. The free Disqus service provides as implementation of this idea and it does so beautifully. I wish importing comments was as easy as integrating the code, but since I only had to do it once, the juice was more than worth the squeeze, as a dear Australian friend of mine likes to say. Enjoy!

This part 3 of a multi-part series on taking a real-world web site (mine) written to be hosted on an ISP (securewebs.com) and moving it to the cloud (Azure). The first two parts talked about moving my SQL Server instance to SQL Azure and getting my legacy ASP.NET MVC 2 code running inside of Visual Studio 2013 and published to Azure. In this installment, we’ll discuss how I configured DNS and SSL to work with my shiny new Azure web site.

Configuring DNS

Now that I have my site hosted on http://sellsbrothers.azurewebsites.net, I’d like to change my DNS entries for sellsbrothers.com and www.sellsbrothers.com to point to it. For some reason I don’t remember, I have my domain’s name servers pointed at microsoftonline.com and I used Office365 to manage them (it has something to do with my Office365 email account, but I’m not sure why that matters…). Anyway, in the Manage DNS section of the Office365 admin pages, there’s a place to enter various DNS record types. To start, I needed to add two CNAME records:

The CNAME records needed to be awarded an IP address by Azure

A CNAME record is an alias to some other name. In this case, we’re aliasing the awveryify.sellsbrothers.com FQDN (the Host name field is really just the part to the left of the domain name to which you’re adding records, sellsbrothers.com in this case). This awverify string is just a string that Azure needs to see before it will tell you the IP address that it’s assigned to you as a way to guarantee that you do, in fact, own the domain. The www host name maps to the Azure web site name, i.e. mapping www.sellsbrothers.com to sellsbrothers.azurewebsites.net. The other DNS record I need is an A record, which maps the main domain, i.e. sellsbrothers.com, to the Azure IP address, which I’ll have to add later once Azure tells me what it is.

After adding the awverify and www host names and waiting for the DNS changes to propagate (an hour or less in most cases), I fired up the configuration screen for my web site and chose the Manage Custom Domains dialog:

Finding the IP address to use in configuring your DNS name server from Azure

Azure provided the IP address after entering the www.sellsbrothers.com domain name. With this in hand, I needed to add the A record:

Adding the Azure IP address to my DNS name servers

An A record is the way to map a host name to an IP address. The use of the @ means the undecorated domain, so I’m mapping sellsbrothers.com to the IP address for sellsbrothers.azurewebsites.net.

Now, this works, but it’s not quite what I wanted. What I really want to do, and what the Azure docs hint at, is to simply have a set of CNAME records, including one that maps the base domain name, i.e. sellsbrothers.com, to sellsbrothers.azurewebsites.net directly and let DNS figure out what the IP address is. This would allow me to tear down my web server and set it up again, letting Azure assign whatever IP address it wanted and without me being required to update my DNS A record if I ever need to do that. However, while I should be able to enter a CNAME record with a @ host name, mapping it to the Azure web site domain name, Office365 the DNS management UI won’t let me do it and Office365 support wasn’t able to help.

However, even if my DNS records weren’t future-proofed the way I’d like them to be, they certainly worked and now both sellsbrothers.com and www.sellsbrothers.com mapped to my new Azure web site, which is where those names are pointing as I write this.

However, there was one more feature I needed before I was done ported my site to Azure: secure posting to my blog, which requires an SSL certificate.

Configuring Azure with SSL

Once I had my domain name flipped over, I had one more feature I needed for my Azure-hosted web site to be complete — I needed to be able to make posts to my blog. I implemented the AtomPub publishing protocol for my web site years ago, mostly because it was a protocol with which I was very familiar and because it was one that Windows Live Writer supports. To make sure that only I could post to my web site, I needed to make sure that my user name and password didn’t transmit in the clear. The easiest way to make that happen was to enable HTTPS on my site using an SSL certificate. Of course, Azure supports HTTPS and SSL and the interface to make this happen is simple:

Azure’s certificate update dialog for added an SSL cert to your web site

Azure requires a file in the PKCS #12 format (generally using the .pfx file extension), which can be a container of several security-related objects, including a certificate. All of this is fine and dandy except that when you go to purchase your SSL cert, you’re not likely to get the file in pfx format, but in X.509 format (.cer or .crt file format). To translate the .crt file into a .pfx file, you need to generate a Certificate Signing Request (.csr) file with the right options so that you keep the private key (.key) file around for the conversion. For a good overview of the various SSL-related file types, check out Kaushal Panday’s excellent blog post.

Now, to actual dig into the nitty gritty, first you’re going to have to choose an SSL provider. Personally, I’m a cheapskate and don’t do any ecommerce on my site, so my needs were modest. I got myself a RapidSSL cert from namecheap.com that only did domain validation for $11/year. After making my choice, the process went smoothly. To get started, you pay your money and upload a Certificate Signing Request (.crs file). I tried a couple different ways to get a csr file, but the one that worked the best was the openssl command line tool for Windows. With that tool installed and a command console (running in admin mode) at the ready, you can follow along with the Get a certificate using OpenSSL section of the Azure documentation on SSL certs and be in good shape.

Just one word of warning if you want to follow along with these instructions yourself: There’s a blurb in there about including intermediate certificates along with the cert for your site. For example, when I get my RapidSSL certificate, it came with a GeoTrust intermediate certificate. Due to a known issue, when I tried to include the GeoTrust cert in my chain of certificates, Azure would reject it. Just dropping that intermediate cert on the floor worked for me, but your mileage may vary.

Configuring for Windows Live Writer

Once I have my SSL uploaded to Azure, now I can configure WLW securely for my new Azure-hosted blog:

Adding a secure login for my Azure-hosted blog

You’ll notice that I use HTTPS as the protocol to let WLW know I’d like it to use encrypted traffic when it’s transmitting my user name and password. The important part of the rest of the configuration is just about what kind of protocol you’d like to use, which is AtomPub in my case:

Configuring WLW for the AtomPub Publishing protocol

If you’re interested in a WLW-compatible implementation of AtomPub written for ASP.NET, you can download the source to my site from github.

Where are we?

Getting your site moved to Azure from an ISP involves more than just making sure you can deploy your code — it also includes making sure your database will work in SQL Azure and configuring your DNS and SSL settings as appropriate for your site’s new home.

At this point, I’ve gotten a web site that’s running well in the cloud, but in the spirit of the cloud, I’ve also got an aging comment system that I replaced with Disqus, a cloud-hosted commenting system, which is the subject of my next post. Don’t miss it!

In our last episode, I talked about the joy and wonder that is moving my site’s ISP-hosted SQL Server instance to SQL Azure. Once I had the data moved over and the site flipped to using the new database, I needed to move the site itself over, which brought joy and wonder all it’s own.

Moving to Visual Studio 2013

I haven’t had to do any major updates to my site since 2010 using Visual Studio 2010. At that time, the state of the art was ASP.NET MVC 2 and Entity Framework 4, which is what I used. And the combination was a pleasant experience, letting me rebuild my site from scratch quickly and producing a site that ran like the wind. In fact, it still runs like the wind. Unfortunately, Visual Studio 2012 stopped supporting MVC 2 (and no surprise, Visual Studio 2013 didn’t add MVC 2 support back). When I tried to load my web site project into Visual Studio 2013, it complained:

This version of Visual Studio is unable to open the following projects

This error message lets me know that there’s a problem and the migration report provides a handy link to upgrade from MVC 2 to MVC 3. The steps aren’t too bad and there’s even a tool to help, but had I followed them, loading the new MVC 3 version of my project into Visual Studio 2013 would’ve given me another error with another migration report and a link to another web page, this time helping me move from MVC 3 to MVC 4 because VS2013 doesn’t support MVC 3, either. And so now I’m thinking, halfway up to my elbows in the move to MVC 3 that Visual Studio 2013 doesn’t like, that maybe there’s another way.

It’s not that there aren’t benefits to move to MVC 4, but that’s not even the latest version. In fact, Microsoft is currently working on two versions of ASP.NET, ASP.NET MVC 5 and ASP.NET v.Next. Even if I do move my site forward two version of MVC, I’ll still be two versions behind. Of course, the new versions have new tools and new features and can walk my dog for me, but by dropping old versions on the floor, I’d left with the choices of running old versions of Visual Studio side-by-side with new ones, upgrading to new versions of MVC just to run the latest version of VS (even if I don’t need any of the new MVC features) or saying “screw it” and just re-writing my web site from scratch. This last option might seem like what Microsoft wants me to do so that they can stop supporting the old versions of MVC, but what’s to stop me from moving to AWS, Linux and Node instead of to ASP.NET v.Next? The real danger of dropping the old versions on the floor; not that I’ll move over to another platform, because I’m an Microsoft fanboy and my MSDN Subscription gives me the OS and the tools for free, but that large paying customers say “screw it” and move their web sites to something that their tools are going to support for more than a few years.

Luckily for me, there is another way: I can cheat. It turns out that if I want to load my MVC 2 project inside of Visual Studio 2013, all I have to do is remove a GUID from the csproj file inside the ProjectTypeGuids element. The GUID in question is listed on step 9 of Microsoft’s guide for upgrading from MVC 2 to MVC 3:

Removing {F85E285D-A4E0-4152-9332-AB1D724D3325} from your MVC 2 project so it will load in Visual Studio 2013

By removing this GUID, I give up some of the productivity tools inside Visual Studio, like easily adding a new controller. However, I’m familiar enough with MVC 2 that I no longer need those tools and being able to actually load my project into the latest version of Visual Studio is more than worth it. Andrew Steele provides more details about this hack in his most excellent StackOverflow post.

Now, to get my MVC 2 project to actually build and run, I needed a copy of the MVC 2 assemblies, which I got from NuGet:

Adding the MVC 2 NuGet package to my project inside Visual Studio 2013

With these changes, I could build my MVC 2 project inside Visual Studio 2013 and run on my local box against my SQL Azure instance. Now I just need to get it up on Azure.

Moving to Azure

Publishing my MVC 2 site to Azure was matter of right-clicking on my project and choosing the Publish option:

Publishing a web site to Azure using the Solution Explorer’s Publish option inside Visual Studio 2013

Selecting the Windows Azure Web Sites as the target and filling in the appropriate credentials was all it took to get my site running on Azure. I did some battle with the “Error to use a section registered as allowDefinition=‘MachineToApplication’ beyond application level” bug in Visual Studio, but the only real issue I had was that Azure seemed to need the “Precompile during publishing” option set or it wasn’t able to run my MVC 2 views when I surfed to them:

Setting the “Precompile during publishing” option for Azure to run my MVC 2 views

With that setting in place, my Azure site just ran at the Azure URL I had requested: http://sellsbrothers.azurewebsites.net.

Where are we?

I’m a fan of the direction of ASP.NET v.Next. The order of magnitude reduction in working set, the open source development and the use of NuGet to designate pieces of the framework that you want are all great things. My objection is that I don’t want to be forced to move forward to new versions of a framework if I don’t need the features. If I am forced, then that’s just churn in working code that’s bound to introduce bugs.

Tune in next time and we’ll discuss the fun I had configuring the DNS settings to make Azure the destination for sellsbrothers.com and to add SSL to enable secure login for posting articles via AtomPub and Windows Live Writer.

In a world where the cloud is not longer the wave of the future, but the reality of the present, it seems pretty clear that it’s time to move sellsbrothers.com from my free ISP hosting (thanks securewebs.com!) to the cloud, specially Microsoft’s Azure. Of course, I’ve had an Azure account since its inception, but there has been lots of work to streamline the Azure development process in the last two years, so now should be the ideal time to jump in and see how blue the waters really are.

As with any modern web property, I’ve got three tiers: presentation, service and database. Since the presentation tier uses server-side generated UI and it’s implementation is bundled together with the service tier, there are two big pieces to move — the ASP.NET site implementation and the SQL Server database instance. I decided to move the database first with the idea that once I got it hosted on Azure, I can simply flip the connection string to point the existing site to the new instance while I was doing the work to move the site separately.

Deploy Database To Windows Azure SQL Database from SSMS

The database for my site does what you’d expect — it keeps track of the posts I make (like this one), the images that go along with each post, the comments that people make on each post, the writing and talks I give (shown on the writing page), book errata, some details about the navigation of the site, etc. In SQL Server Management Studio (SSMS), it looks pretty much like you’d expect:

sellsbrothers.com loaded into SQL Server Management Studio

However, before moving to Azure SQL Server, I needed a SQL Azure instance to move the data to, so I fired up the Azure portal and created one:

Creating a new SQL Azure database

In this case, I chose to create a new SQL Azure instance on a new machine, which Azure will spin up for us in a minute of two (and hence the wonder and beauty that is the cloud). I choose the Quick Create option instead of the Import option because the Import option required me to provide a .bacpac file, which was something I wasn’t familiar with. After creating the SQL Server instance and the corresponding server, clicking on the new server name (di5fa5p2lg in this case) gave me the properties of that server, including the Manage URL:

SQL Azure database properties

If you click on the Manage URL, you will have a web interface for interacting with your SQL Azure server, but more importantly for this exercise, the FQDN is what I needed to plug into SSMS so that I can connect to that server. I’ll need that in a minute, because in the meantime, I’d discovered what looked like the killer feature for my needs in the 2014 edition of SSMS:

Deploy Database to Windows Azure Database in SSMS 2014

By right-clicking on the database on my ISP in SSMS and choosing Tasks, I had the Deploy Database To Windows Azure SQL Database option. I was so happy to choose this option and see the Deployment Settings screen of the Deploy Database dialog:

SSMS Deploy Database dialog

Notice the Server connection is filled in with the name of my new SQL Server instance on Azure. It started blank and I filled it in by pushing the Connect button:

SSMS Connect to Server dialog

The Server name field of the Connect to Server dialog is where the FQDN we pulled from the Manage URL field of Azure database server properties screen earlier and the credentials are the same as I set when I created the database. However, filling in this dialog for the first time gave me some trouble:

SQL Azure: Cannot open server ‘foo’ requested by the login

SQL Azure is doing the right thing here to keep your databases secure by disabling access to any machine that’s not itself managed by Azure. To enable access from your client, look for the “Set up Windows Azure firewall rules for this IP address” option on the SQL database properties page in your Azure portal. You’ll end up with a server firewall rule that looks like the following (and that you may want to remove when you’re done with it):

SQL Azure server firewall rules

Once the firewall has been configured, filling in the connection properties and starting the database deployment from my ISP to Azure was when my hopes and dreams were crushed:

SSMS Deploy Database: Operation Failed

Clicking on the Error links all reported the same thing:

Error validating element dt_checkoutobject: Deprecated feature ‘String literals as column aliases’ is not supported by SQL Azure

At this point, all I could think was “what the heck is dt_checkoutobject” (it’s something that Microsoft added to my database), what does it mean for to use string literals as column aliases (it’s a deprecated feature that SQL Azure doesn’t support) and why would Microsoft deprecate a feature that they used themselves on a stored proc that they snuck into my database?! Unfortunately, we’ll never know the answer to that last question. However, my righteous indignation went away as I dug into my schema and found several more features that SQL Azure doesn’t support that I put into my own schema (primarily it was the lack of clustered indexes for primary keys, which SQL Azure requires to keep replicas of your database in the cloud). Even worse, I found one table that listed errata for my books that didn’t have a primary key at all and because no one was keeping track of data integrity, all of the data was in that table twice (I can’t blame THAT on Microsoft : ).

And just in case you think you can get around these requirements and sneak your database into SQL Azure w/o the updates, manually importing your data using a bacpac file is even harder, since you now have to make the changes to your database before you can create the bacpac file and you have to upload the file to Azure’s blob storage, which requires a whole other tool that Microsoft doesn’t even provide.

Making your Database SQL Azure-compatible using Visual Studio

To make my SQL database compatible with SQL Azure required changing the schema for my database. Since I didn’t want to change the schema for a running database on my ISP, I ended up copying the database from my ISP onto my local machine and making my schema changes there. Getting to point of SQL Azure-compatibility, however, required me to have the details of which SQL constructs SQL Azure supported and didn’t support. Microsoft provides overview guidance on the limitations of SQL Azure, but it’s not like having an automated tool that can check every line of your SQL. Luckily, Microsoft provides such a tool built into Visual Studio.

To bring Microsoft’ SQL compiler to bear to check for SQL Azure compatibility requires using VS to create a SQL Server Database Project and then pointing it at the database you’d like to import from (which is the one copied to my local machine from my ISP in my case). After you’ve imported your database’s schema, doing a build will check your SQL for you. To get VS to check your SQL for Azure-compatibility, simply bring up the project settings and choose Windows Azure SQL Database as the Target platform:

Visual Studio 2014: Setting Database Project Target Platform

With this setting in place, compiling your project will tell you what’s wrong with your SQL from an Azure point-of-view. Once you’ve fixed your schema (which may require fixing your data, too), then you can generate a change script that updates your database in-place to make it Azure-compatible. For more details, check out Bill Gibson’s excellent article Migrating a Database to SQL Azure using SSDT.

The Connection String

Once the database has been deployed and tested (SSMS or the Manage URL are both good ways to test that your data is hosted the way you think it should be), then it’s merely a matter of changing the connection string to point to the SQL Azure instance. You can compose the connection string yourself or you can choose the “View connection strings for ADO.NET, ODBC, PHP and JDBC” option from your database properties page on Azure:

SQL Azure: Connection Strings

You’ll notice that while I blocked out some of the details of the connection string in my paranoia, that Azure itself is too paranoid to show the password; don’t forget to insert it yourself and to put it into a .config file that doesn’t make it into the SCCS.

Where are we?

In porting sellsbrothers.com from an ISP to Azure, I started with the database. The tools are there (nice tools, in fact), but you’ll need to make sure that your database schema is SQL Azure-compatible, which can take some doing. In the next installment, I’ll talk about how I moved the implementation of the site itself, which was not trivial, as it is implemented in ASP.NET MVC 2, which has been long abandoned by Microsoft.

If you’d like to check out the final implementation in advance of my next post, you help yourself to the sellsbrothers.com project on github. Enjoy.

I’ve been watching the Portland startup scene for years. However, in the last 12 months, it’s really started to take off, so when I had an opportunity to mentor at the recent Portland Startup Weekend, I was all over it. I got to do and see all kinds of wonderful things at PDXSW, but one of the best was meeting Thubten Comerford and Tyler Phillipi. Between the three of us, we’re bringing the very popular Tech Meetup conference format to Portland.

The idea of a Tech Meetup is meant to be focused on pure tech. In fact, at the largest of the Tech Meetups in New York (33,000 members strong!), they have a rule where it’s actually rude to ask about the business model. The Tech Meetups are tech for tech’s sake. If you’re in a company big or small or if you’re just playing, cool tech always has a place at the Portland Tech Meetup.

The format is simple and if you’re familiar with the way they do things in Boulder or Seattle, you’re already familiar with it. Starting on January 20th, 2014, every 3rd Monday at 6pm, we’ll open the doors for some networking time, providing free food and drink to grease the skids. At 7pm, we’ll start the tech presentation portion of the evening, which should be at least five tiny talks from tech presenters of all kinds. After the talks, we’ll wrap up around 8pm and then head to the local water hold for the debrief.

If this sounds interesting to you, sign up right now!

If you’d like to present, drop me a line!

If you’d like to sponsor, let Thubten know.

We’re very excited about bringing this successful event to Portland, so don’t be shy about jumping in; the water is fine…

If you recall from REPL for the Rosyln CTP 10/2011, I’ve been playing around building a little C# REPL app using Roslyn. That version was built as a Console application, but I’ve refactored and rebuilt it as a WPF application:

You can download the source code for both the Console and the WPF versions here:

RoslynRepl Sample Download

The benefit of a real GUI app is that output selection makes a lot more sense and that you could imagine real data visualization into data controls instead of just into strings. However, implementing a REPL shell in a GUI environment requires doing things considerably differently than in a Console app. Besides the stupid things I did, like doing a lot of Console.Write, and things that don’t make sense, like #exit or #prompt, there are a few interesting things that I did with this code, including handling partial submissions, rethinking history and rewiring Console.Write (just ’cuz it’s stupid when I do it doesn’t mean that it shouldn’t work).

Partial Submissions

In this REPL, I decided that Enter means “execute” or “newline” depending on whether the submission is complete enough, according to Roslyn, to execute or not. If it is, I execute it, produce the output and move focus to either the next or a new submission TextBox. If the submission isn’t yet complete, e.g. “void SayHi() {”, then I just put in a newline. Further, I do some work to work properly with selections, i.e. if you press Enter when there’s a selection, the selection will be replaced with the Enter key.

So far I like this model a lot, since I don’t have to something like separate “execute” and “newline” into Enter and Alt+Enter or some such.

Rethinking History

In a GUI shell with partial submissions and multi-line editing, the arrows are important editing keys, so can’t be used for access to previous lines in history. Further, a GUI apps makes it very easy to simply scroll to the command that you want via the mouse or Shift+Tab, so there’s not a lot of use for Alt+Arrow keys. Pressing Enter again replaces the old output (or error) with new output (or error):

Currently when you re-execute a command from history, the command stays where it is in the history sequence, but it could as easily move to the end. I haven’t yet decided which I like better.

Redirecting Console.Write

Since this is a REPL environment works and acts like a shell, I expect that Console.Write (and it’s cousins like Console.WriteLine) to work. However, to make that work, I need to redirect standard output:

Console.SetOut(new ReplHostTextWriter(host));

The ReplTextWriterClass simply forwards the text onto the host:

class ReplHostTextWriter : TextWriter {
  readonly IReplHost host;


  public ReplHostTextWriter(IReplHost host) {
    this.host = host;
  }

  public override void Write(char value) {
    host.Write(value.ToString());
  }

  public override Encoding Encoding {
    get { return Encoding.Default; }
  }
}

The hosts implementation of IReplHost.Write simply forwards it onto the currently executing submission (the ReplSubmissionControl represents both a submission’s input and output bundled together). You’ll notice that the TextWriter takes each character one at a time. It would be nice to do some buffering for efficiency, but you’d also like the output to appear as its produced, so I opted out of buffering.

However, one thing I don’t like is the extra newline at the end of most string output. I want the main window to decide how things are output, setting margins and the newline looks like a wacky margin, so the trailing CR/LF had to go. That’s an interesting algorithm to implement, however, since the characters come in one at a time and not line-by-line. I want separating newlines to appear, just not trailing newlines. I implement this policy with the TrimmedStringBuilder class:

// Output a stream of strings with \r\n pairs potentially spread across strings,
// trimming the trailing \r and \r\n to avoid the output containing the extra spacing.
class TrimmedStringBuilder {
  readonly StringBuilder sb;

  public TrimmedStringBuilder(string s = "") {
    sb = new StringBuilder(s);
  }

  public void Clear() {
    sb.Clear();
  }

  public void Append(string s) {
    sb.Append(s);
  }

  public override string ToString() {
    int len = sb.Length;

    if (len >= 1 && sb[len - 1] == '\r') {
      len -= 1;
    }
    else if (len >= 2 && sb[len - 2] == '\r' && sb[len - 1] == '\n') {
      len -= 2;
    }

    return sb.ToString(0, len);
  }
}

Usage inside the ReplSubmissionControl.Write method is like so:

public partial class ReplSubmissionControl : UserControl {
  ...
  TrimmedStringBuilder trimmedOutput = new TrimmedStringBuilder();

  public void Write(string s) {
    if (s == null) { trimmedOutput.Clear(); }
    else { trimmedOutput.Append(s); }

    consoleContainer.Content = GetTextControl(trimmedOutput.ToString());
  }
}

Now, as the input comes in one character at a time, the trailing newlines are removed but separating newlines are kept. Also, you may be interested to know that the GetTextControl function builds a new read-only TextBox control on the fly to host the string content. This is so that the text can be selected, which isn’t possible when you set the content directly.

Right now, there’s no support for Console.Read, since I don’t really know how I want that to happen yet. Pop-up a dialog box? Something else?

Completions, Syntax Highlighting and Auto-indent

I was a few hundred lines into implementing completions using Roslyn with the help of the Roslyn team when I realized two things:

1. Implementing completions to mimic the VS editor is hard.
2. Completions aren’t enough — I really want an entire C# editor with completions, syntax highlighting and auto-indentation.

Maybe a future release of Roslyn will fix one or both of these issues, but for now, both are out of scope for my little REPL project.

In part 1 of this now multi-part series (who knew?), I discussed my initial attempts at moving my digital life into the cloud, including files, music, photos, notes, task lists, mail, contacts, calendar and PC games.There were some issues, however, and some things that I forgot, so we have part 2.

Before we get to that, however, it’s interesting (for me, at least) to think about why it’s important to be able to move things into the cloud. Lots of vendors are busy making this possible, but why? There are backup reasons, of course, so that a fire or other natural disaster doesn’t wipe out all of the family pictures. There are also the ease of sharing, since email makes a very poor file sharing system. Also, multi-device access is certainly useful, since the world has moved into a heterogeneous OS world again as smartphones and tablets take their place at the table with PCs.

For me, however, moving my data into the cloud is about freedom.

The cloud enables me to get myself bootstrapped with data associated with my personal or business life, using whatever device or OS I feel like using that day. It provides me freedom of location or vendor.

The cloud is still forming, however, so hasn’t really been able to make this a seamless experience, which is why I’m onto part 2 of this series.

Mail, Contacts and Calendar

Hotmail is a fine system for online access to mail, contacts and calendar that integrates well with Windows Phone 7. However, the integration with desktop Outlook and my custom domain isn’t good enough yet to rely on. The primary problem was the Hotmail Outlook Connector, which isn’t ready yet for prime time. It worked great with calendar and contacts, but fell down badly when it came to large email folders that I moved from my PST file. It never showed the sync’ing progress as complete, which made me uncomfortable that it never actually completed sync’ing and therefore my data wasn’t safe. Also, when I sent an email from Hotmail, either via the web or via Outlook, it showed the reply address as hotmail_44fe54cff788bdde@live.com. I assume the latter would’ve been fixed with Windows Live custom domains, but the former was the real deal-killer for me.

Also, I heard that Google Apps is the way to go, but that also requires some special software to enable sync’ing with desktop Outlook — I wanted something that was native to both Outlook 2010 and Windows Phone 7. Further, it cost money, so if I was going to pay, I wanted something that Microsoft was going to integrate well with.

So, I bit the bullet and hooked myself with the latest in hosted Exchange — Microsoft Office 365. That’s what I’m using now and just like the on-premise Exchange that worked great for me as a Microsoft employee, I’ve been very happy with it. However, because of the way I was using it, it was a pain to configure properly for use in hosting my csells@sellsbrothers.com email.

The easy way to configure Office 365 is to let it be the DNS name manager, which lets it manage everything for you, including your web site (via SharePoint), your mail, your Lync settings and any future service they care to tack on. However, that doesn’t work for me, since I didn’t want to move my 16-year-old web site into SharePoint (duh). Instead, I wanted to leave my DNS name manager at securewebs.com, which has been a fabulous web hosting ISP for me.

A slightly harder way to configure Office 365 for use with your domain is to only be used for selective services, e.g. set the MX record for mail, but don’t mess with the CNAME record for your web site. This would’ve been nice, too, except I don’t want to move all of the email accounts on sellsbrothers.com — only csells. Why? Well, that’s a family matter.

Over the years at family gatherings, to seem geek cool, I’ve offered free email boxes to my relatives. “Oh? You’re moving to another ISP again? Why don’t you move your email to sellsbrothers.com and then you can keep the same email address forever! And the best part is that it’s free!”

Now, of course, I’d recommend folks get an email address on hotmail or gmail, but this all started before the email storage wars back when you needed an actual invitation to set up a gmail.com account. Now I’ve got half a dozen family members with “permanent” and “free” email boxes and I don’t want to a) move them, b) charge them or c) pay for them myself on Office 365.

As cheap as you might think I am, it’s really migration that I worry most about — having successfully gotten them set up on their phones and PCs with their current email host, I don’t want to do that again for Outlook or migrate their email. Maybe it’s easy, maybe it’s hard. We’ll never know ’cuz I’m not doing it!

So now, I have to make csells@sellsbrothers.com sync with Office 365 and leave everyone else alone. This is the hardest way to use Office 365 and involved the following:

• Set up a custom domain in Office 365: sellsbrothers.onmicrosoft.com
• Add myself as a user: csells@sellsbrothers.onmicrosoft.com
• Verify that I own sellsbrothers.com by asking securewebs.com support to add a DNS TXT record as specified by Office 365 (this took two weeks and a dozen emails)
• Make csells@sellsbrothers.com the primary email on that account
• Make csells@sellsbrothers.com the From address by removing csells@sellsbrothers.onmicrosoft.com and adding it back again
• Configure my ISP email (SmarterMail) to forward csells@sellsbrothers.com email to csells@sellsbrothers.onmicrosoft.com (I’m not also deleting the email on my ISP account yet when it forwards, but eventually I plan to)
• Login to my Outlook Web Access account on http://mail.office365.com
• Find my Outlook host name via Help | About | Host name (ch1prd0502.outlook.com) for use as my Outlook server on my Windows Phone 7 (along with my From email address: csells@sellsbrothers.com)
• Stumbling onto the right technical forum post to figure out how to configure desktop Outlook 2010 using advanced settings:
• Server: ch1prd0502.mailbox.outlook.com (my host name with “mailbox” thrown in)
• User name: csells@sellsbrothers.com (my From address)
• Exchange Proxy Server: ch1prd0502.outlook.com (my Host name again)
• Check both checkboxes to use HTTP first before TCP/IP
• Authentication: Basic Authentication

Obviously, this is a crappy configuration experience, but no amount of manual updates to Outlook provided by the Office 365 site seemed to help. It was nice that the WP7 Outlook was much easier, although I’d really loved to have just told desktop Outlook that I was an Office 365 user and had it figure out all the touchy config settings.

Everything seems solid except one minor annoyance: when I do a Reply All, csells@sellsbrothers.com stays in the list because my mail programs don’t know that my csells@sellsbrothers.com and csells@sellsbrothers.onmicrosoft.com email addresses are logically the same. I assume if I was hosting my MX records at Office 365, this problem, along with the crappy config experience, would go away.

The good news is that I’ve got access to my full range of Mail, Contacts and Calendar from the web, my phone and my desktop, including multi-GB email folders I’ve copied over from my PST file, all for $6/month. Had I to do it over again, I’d have long ago moved my family to hotmail and avoided the config nightmare. I may yet do just that.

Encrypted Files

With my mail et al sorted, my next fix from last time was the lack of confidence in my most sensitive files with Dropbox. Dropbox can be hacked or subpoenaed like anyone else, so I want a client-side encryption solution. Dropbox may someday provide this themselves, but currently they gain a great deal of storage savings by detecting duplicate blocks amongst their users, saving significantly on uploads and storage, which client-side encryption disrupts. In the meantime, I really want an app that encrypts on the client and drops my data into Dropbox, which BoxCryptor does nicely.

In addition to supporting Windows, BoxCryptor also supports MacOS, iOS and Android, although not WP7 yet. Further, it’s free for 2GB and only a $40 one-time fee for unlimited data, so it’s cheap, too.

I also looked at SecretSync, which has a similar cross-platform story and pricing model (although it’s $40/year instead of $40/once), but it requires Java and I don’t put that on my box. For an open source solution, you may be interested in TrueCrypt.

Financial Data

I’m a mint.com user. I like the idea of an all-up look at my finances across 29 online financial accounts. However, as a backup of that data, I wrote a mint.com scraping tool that downloads the CSV transactions export file and digs current snapshot data out of the homepage HTML. The format on the web site is constantly changing of course, so it’s a support problem, but having that data even a little messed up over time is way better than not having it at all, so I’m happy. The data itself goes into CSV files that I can query with LINQPad and that are stored in my Dropbox folder, which keeps them sync’d.

Books and Bookmarks

I can’t believe I missed this last time, but one of the big things I keep in the in the cloud is my set of Amazon Kindle books. I think that the proprietary format and DRM of Kindle materials will eventually open up because of competition, but until then, Amazon has been a great steward of my online books and bookmarks, providing me clients for all new platforms as well as their own e-ink-based hardware. I have an extensive book collection (this is just part of it), but am adding to the physical part of it no more.

Further, in the case that I have the “what the hell was that book I used to have?” moment after I finally truck all of my books off to Powell’s, the Brothers Sells have scanned all of the ISBN numbers from my 500+ books into LibraryThing. I won’t have the books anymore, but at least I’ll be able to browse, refresh my memory and add the books to Kindle on demand. The reason I picked LibraryThing is because it was easy to get all of the book metadata from just an ISBN (so it’s easy to spot data entry errors early), it’s easy to export from in a CSV file and, should I decide, easy to user their API.

App Specifics

In addition to the big categories, several apps keep data important to me:

• Twitter keeps Twitter users I’m following and searches
• Facebook keeps Facebook contacts, which is nice because they can maintain their own contact data for me and I don’t have to be constantly out of data with my copy
• Windows Live Messenger keeps my IM contacts for me, although Facebook has largely replaced that for IM chatting
• As of the latest update, Xbox game state in the cloud for me, although I’m not a big enough gamer that I really need it anywhere else except my home console. I assume in the future, MS will also keep the Xbox games I’ve purchased in the cloud as well
• Hulu keeps a list of several TV shows I like and notifies me when new episodes are available
• Netflix keeps a partial list of movies I’d like to see, but unfortunately not all of them
• I keep my blog posts in an instance of SQL Server maintained on securewebs.com, which I assume they backup regularly. Someday I’ll write the script to pull that data out into my Dropbox just in case. The source code for the site itself is already stored in Dropbox, so I’m set there
• Favorites: I don’t have a good app here, but I’d love it if some app could keep my IE favorites sync’d between my phone and my other computers. Suggestions?

Things Left On The Ground

As you may have surmised, I don’t put a lot of sentimental value in physical things. They’re not nearly as important to me as people, experiences or data. However, there are some things that I’d want to rescue in case of disaster given the chance:

• A few wrist watches that reminds me of a special person or event
• An inscribed copy of The Complete Sherlock Holmes that my grandfather, my father and I have all read
• Inscribed copies of The Hobbit and The Lord of the Rings trilogy that my mother read to me as a child
• A leather bound copy of Batman: The Dark Knight Returns because Frank Miller kicks ass
• Two pieces of marble and maple furniture that my grandfather built to withstand the onslaught from my mother barreling through each room at top speed as a child (I’d have liked to see the first collision of the immovable object and the irresistible force that day!)

As hard as I try, I can’t think of anything else. Should I have to jam, my plan is to place these few items into safe keeping and sell, donate and/or toss the rest.

Where Are We?

As I write this, I’m sitting in a Starbucks in Sandy, OR, 20 minutes from a cabin I’m renting for a few days. When I’m done here, I’ll explore the town, see a movie and make myself some dinner. I won’t worry about my phone, my laptop or my home being lost or destroyed, since 98% of the possessions I deem most valuable are being managed by cloud vendors I trust.

The cloud doesn’t just represent a place to backup or store data — it represents a way of life.

My data stores a lifetime of experiences, people and knowledge. By keeping it safe and available no matter where I go, I gain the freedom to wander, to experience new physical places and new hardware and software solutions, all without being unduly burdened.

Creative work requires a comfortable place to labor filled with the tools and the materials the worker needs to be creative. Today my tools are an Apple MacBook, Windows 7, Office 2010, Visual Studio 2010 and a Samsung Focus. Yesterday those tools were different and I’m sure they’ll be different again tomorrow. However, while other people build up their place with comfortable things around them — a bookshelf for reference, a comfy chair, knick-knack reminders of events or trips — my place is a lifetime of data and anywhere that provides access to electrons and bits.

Having my data safe, secure and available makes me feel comfortable, creative and free.

With the exception of //build/, I haven’t really been a public part of the Microsoft developer community for about a year. So, to make up for some lost time, I’m giving a talk about some of the //build/ bits at the Portland Area .NET User Group first thing in the new year. This means that I need a running installation of the Windows 8 Developer Preview on my new laptop, ’cuz THE MAN took my old laptop back when I handed in my badge (although, to be fair, they paid for it in the first place : ).

My constraints were as follows:

• I really like boot-to-VHD. I find that any other kind of virtualization technology slows an OS down enough that it negatively affects any talk I would give.
• I have an existing VHD I wanted to reuse with Win8 and VS11 installed and running just fine already.
• I am running it on a MacBook Air. It’s the big one with quad-core i7, 4GB of RAM and 256GB of SSD, so it’s got the muscle but it needs to drivers to make everything work properly.
• I’m running Windows 7 on my MacBook. The wonderful Boot Camp Assistant in MacOS makes it a snap to get Win7 up and running on a MacBook, but making it run with Win7 and Win8 is a special challenge.

So, with all of that in mind, of course I started with Hanselman’s Guide to Installing and Booting Windows 8 Developer Preview off a VHD post. If you’re willing to build a new VHD, that’s the way to go. However, I was able to use the techniques I learned from that post, especially the comment section and a couple tips from my friend Brian Randall to make my existing Win8 VHD work. Some of this may work for you even if you don’t have a MacBook Air.

Getting Windows 7 Running on my MacBook Air

I started with a virginal MacBook and used the built in Boot Camp to create a Win7 partition, point to a Win7 Ultimate ISO I have on a network share for just these kinds of emergencies and get it installed and running. It wasn’t seamless, but Bing was helpful here to straighten out the curves.

Replacing the Boot Manager

The way I like to create VHDs is via Windows Server 2008 and Hyper-V. Once I have the VHD, I drop it onto the c:\vhd folder on my computer, do a little bcdedit magic and boom: when I reboot, I’ve got a new entry from which to choose my OS of the moment.

However, Win8 doesn’t boot from the Win7 boot manager, so the first thing I needed to do (as implied by the comments in Scott’s post) was use bcdboot to replace the Win7 book manager with the Win8 boot manager. To do that, boot into Win7 and fire up the Disk Management tool (Start | Run: diskmgmt.msc). Select your BOOTCAMP drive and choose Action | Attach VHD. Choose the path to your VHD and you’ll get another virtual disk:

In my case, C was my Win7 Boot Camp HD and F was my Win8 VHD. Now, start an elevated command prompt and use bcdboot to replace the Win7 boot manager with the Win8 book manager.

DISCLAIMER: I’m stealing the “works on my machine” graphic from Hanselman’s site because this action replaces a shipping, maintained, supported boot manager with one that is still in “developer preview” mode. Make sure you have your computer backed up before you do this. I am a trained professional. Do not attempt this at home. All stunts performed on a closed course. Some assembly required. Void where prohibited. I’m just sayin’.

Now that you’ve got the right boot manager in place, getting Win8 to boot requires bcdedit.

Getting Windows 8 to Boot

Scott’s post on booting to VHD involves bcdedit, which describes adding a new boot option in the “Setting up your Windows Boot Menu to boot to an Existing VHD” section:

Use bcdedit to point to the Win8 VHD.

Logging into Windows 8 on a MacBook

Now when you boot your MacBook, you’ll choose to boot to your Windows partition as you always have (which should just happen automatically), but then the Win8 book manager will kick in and you choose your Windows 7 install or your new Windows 8 install. Booting into Windows 8 shows you the login screen as normal, but now you have another problem.

The MacBook keyboard comes without a Windows Delete button. Oh sure, it’s labeled “delete” in trendy lowercase letters, but it’s really the equivalent of the Windows Backspace button. And that’s a problem, because you need to press Ctrl+Alt+Del to log into Win8.

Of course, Apple thought of that, so they created the Boot Camp drivers for Windows that maps fn+delete to Delete, but you can only install them after you’ve logged in.

So how do you log into a MacBook without a Delete button? Easy. You attach an external USB keyboard, press that three-fingered salute and login as normal.

Once you’re in that first time, you can install the Boot Camp drivers and never have to use the external keyboard again.

Installing the Boot Camp Drivers on Win8

When I created the Boot Camp USB to install Win7, it came with a set of drivers in the WindowsSupport folder with a wonderful setup.exe that makes Windows run great on the MacBook. Unfortunately, when you try to run it, you get a message that says you can’t:

If you search the internet, you can find folks that have gotten past this by tricking setup.exe into thinking it’s running on Win7, but you’ll also find that those tricks don’t seem to work for 64-bit installs on MacBook Air, i.e. the one I was doing. However, this is where Brian had another suggestion: you can edit the Boot Camp MSI itself.

DISCLAIMER: This is something that I made work surprising well on my own personal MacBook Air, but I provide no guarantee that it won’t cause your computer to burst into flames on an international flight causing your body to be lost at sea. These techniques are not supported by Microsoft, Apple or the American Dental Association. You’ve been warned.

You may wonder, “To what MSI is Mr. Sells referring?” And I answer: WindowsSupport\Drivers\Apple\BootCamp64.msi. This is the 64-bit MSI with the check in it for Windows 7. To make it work for Windows 8, you need to edit the MSI and change the version number. And to do that, the easiest tool I know of is the unsupported, discontinued Orca MSI editor from Microsoft, now hosted on technipages.com. Running Orca allows you to edit BootCamp64.msi and change the Windows version part of the LaunchCondition from 601 (Windows 7) to 602 (Windows 8):

Once you’ve changed this version, WindowsSupport\setup.exe seems to run just fine, installing the keyboard entries that allow you to login and the control panel that allows you to customize everything.

Where Are We?

Starting from a Boot Camp installation of Windows 7 on my MacBook Air, I showed you how I was able to get Windows 8 booting from a VHD. It wasn’t pretty and it required tips from all over the internet. I gather them here today so that future anthropologists will know how hard we worked to enable the coming of our robotic overlords. If you’re able to use these instructions to expedite their arrival, I’m sure they’ll take that into consideration when they’re sorting us into work details.

P.S. This post is dedicated to Jerry Pournelle. I used to pour over his Byte magazine column every month like he was the computer Sherlock Holmes.

For years, I’ve maintained a single “main” computer. It was the computer that was the central authority of all of the personal data I’d accumulated over the years and from which it made me uncomfortable to be separated. Because I needed a single computer for everything, it had to work on my couch, on a plane, on a desk and everywhere else I ever needed to go. Also, it couldn’t have a giant monitor or multiple monitors, because it had to go everywhere. All of this was because I needed all of my data with me all of the time.

My process for moving to a new computer used to include a lot of manual copying of files from the old D hard drive (D is for Data) to my new hard drive, which was also carefully partitioned into C for Windows, Office, Visual Studio, etc. and D for a lifetime of books and articles, coding projects and utilities I’ve collected over the years, e.g. LinqPad, Reflector, WinMerge, etc. This is 30GB of stuff I wanted access to at all times. I was also backing up via Windows Home Server, keeping photos and music on the WHS box (another 30GB), then backing that up to the cloud via KeepVault. And finally, as I upgraded HDs to go bigger or go to solid state, I kept each old HD around as another redundant backup.

All of that gave me some confidence that I was actually keeping my data safe right up until my Windows Home Server crashed the system HD and I found out that the redundancy of WHS doesn’t quite work the way you’d like (this was before I installed KeepVault). This was a first generation HP Home Server box and when it went down, I took it apart so I could attach a monitor, keyboard and mouse to diagnose it, pulled the HDs out so I could read what files I could and ultimately had to drop it off in Redmond with the WHS team so I could get it up and running again.

There are some files I never got back.

KeepVault gave me back some of the confidence I’d had before WHS crashed, but they didn’t provide me a way to see what files they were backing up, so I didn’t have the transparency I wanted to be confident. Further, they don’t have clients on every kind of platform like Dropbox does.

Of course, simply sync’ing files isn’t enough — sync’ing my 10GB Outlook PST file every time I got a new email was not a good way to share 20 years of contacts, email and calendar items.

The trick is to sync each kind of data in the right way, be confident that it’s safe and have access to it across the various platforms I use: Windows, Windows Phone 7, iOS and possibly Android (you know, if I feel like walking on the wild side!). And since I’m currently under employed (my new gig doesn’t start till the new year), I figured I’d do it once and do it right. I almost got there.

Files

Let’s start easy: files. Dropbox has made this a no-brainer. You install the software on any platform you care to use, drop everything you want into the folder and it just works, keeping files in sync on the cloud and across platforms, giving you adequate (although not great) status as it does so. Most platforms are supported natively, but even on platforms that aren’t, there are often alternative clients, e.g. I’m using Boxfiles for Windows Phone 7. When I gave up my Microsoft laptop, instead of doing the dance of the copy fairy to my new Mac Book Air, I installed Dropbox on both computers, dropped everything I want backed up and sync’d between computers into the Dropbox folder. 36 hours and 30GB later, all of it was copied into the cloud and onto my new laptop, at which point I reformatted my Microsoft laptop and handed it into my boss.

Further, as a replacement for WHS and KeepVault, I now keep all of the files that I was keeping just on my WHS server — photos and music primarily — into Dropbox.

This keeps me the confidence I need to know that my files are safe and backed up to the cloud, while making it very easy to keep it backed up locally by simply running Dropbox on more than one computer at my house. If at any time, I don’t want those files on any one computer, I tell Dropbox to stop sync’ing those folders, delete the local cache and I’m all done.

There are two tricks that I used to really make Dropbox sing for me. The first is to change my life: I no longer partition my HDs into C and D. The reason I’d always done that was so that I could repave my C with a fresh Windows, Office and VS install every six months w/o having to recopy all my data. Windows 7 makes this largely unnecessary anyway (bit rot is way down on Win7), but now it doesn’t matter — I can blow any computer away at will now, knowing that Dropbox has my back. In fact, Dropbox is my new D drive, but it’s better than that because it’s dynamic. The C drive is my one pool of space instead of having to guess ahead of time how to split the space between C and D.

The other thing I did was embrace my previous life: I wanted to keep D:\ at my fingertips as my logical “Data” drive. Luckily, Windows provides the “subst” command to do just that. Further, ntwind software provides the fabulous VSubst utility to do the mapping and keep it between reboots:

Now, I’ve got all the convenience of a dedicated “data” drive backed up to the cloud and sync’d between computers. Because I needed 60GB to start, I’m paying $200/year to Dropbox for their 100GB plan. This is more expensive than I’d like, but worth it to me for the data I’m storing.

There is a hitch in this story, however. Right now on Dropbox, data and metadata is available to Dropbox employees and therefore to anyone that hacks Dropbox (like the government). I don’t like that and for my very most sensitive data, I keep it off of Dropbox. When Dropbox employees themselves aren’t able to read Dropbox data or metadata, then I’ll move the sensitive data there, too.

Music

I’m not actually very happy with how I’m storing music. I can play all my music on any PC, but I can only play it one song at a time on my WP7 because there’s no Dropbox music client. I could use the Amazon cloud drive that provides unlimited music storage for $20/year, but there’s no WP7 client for that, either. Or I could spend $100/year on Amazon and get my 100GB of storage, but their client isn’t as widely available as Dropbox. Ironically, Dropbox is using Amazon as their backend, so hopefully increased pressure in this space will drop Dropbox’s prices over time.

Photos

I’m not using Facebook or Flicr for my photos simply because I’m lazy. It’s very easy to copy a bunch of files into Dropbox and have the sync’ing just happen. I don’t want to futz with the Facebook and Flickr web interfaces for 15GB worth of photos. Right now, this is the digital equivalent of a shoebox full of 8x10s, but at least I’ve got it all if the house burns down.

Notes and Tasklist

For general, freeform notes, I moved away from Evernote when they took the search hotkey away on the Windows client (no Ctrl+F? really?) and went to OneNote. The web client sucks, but it’s better than nothing and the Windows and WP7 clients rock. I have a few notes pinned to my WP7 home screen that I use for groceries, tasks, etc., and I have all of my favorite recipes in there, too, along with my relatives’ wi-fi passwords that they don’t remember themselves, a recording of my son snoring, etc. It’s a fabulous way to keep track of random data across platforms.

On the task list side, I only sorta use OneNote for that. I also send myself emails and write little TODO.txt files every time I get a little bee in my bonnet. I’ve never found that the Exchange tasks sync well enough between platforms to invest in them. Maybe someday.

Mail, Contacts and Calendar

And speaking of Exchange, that’s a piece of software that Microsoft spoiled me on thoroughly. This is sync that works very well for contacts, emails and calendar items. IMAP does email folders, but server implementations are spotty. For years, I used Exchange for my personal contacts and calendar, only keeping my personal email separate in a giant PST file, pulling it down via POP3. This can sorta be made to work, but what I really wanted was hosted Exchange.

However, what I found cost between $5 and $11 a month per user. I’d probably have gone with Office 365 for sellsbrothers.com mail, even at $5/month except for two reasons. The first is that Microsoft requires you to move your entire DNS record to them, not just the MX record, which means there is all kinds of hassle getting sellsbrothers.com working again. They do this so that they can get all of the DNS records working easily for Lync, Sharepoint, etc., but I don’t want those things, so it’s just a PITA for me. If they change this, I’d probably move except for the other problem: I’m not the only user on sellsbrothers.com.

For years to be the big shot at family gatherings, I’ve been offering up permanent, free email addresses on my domain. That’s all well and good, but now to maintain my geek cred, I need to keep my mom, my step-mom, my brother, my sons, etc., in an email server that works and one that they don’t have to pay for. So, while I was willing to pay $5/month for hosted exchange for me, I wasn’t willing to pay it for my relatives, too!

One option I tried was asking securewebs.com (my rocking ISP!) to upgrade to SmarterMail 8.x, but that didn’t work. I even footed the one-time fee of $200 for the ActiveSync support for SmarterMail, but I couldn’t make that sync from Outlook on the desktop or the phone either.

Eventually I made an imperfect solution work: Hotmail. The nice thing about Hotmail is that it’s free for 25GB (yay webmail storage wars!) and it syncs contacts, mail and calendar items just like I want. Further, with some effort (vague error messages are not useful!), I was able to get Hotmail to pull in my personal email. And, after installing the Outlook Hotmail Connector (explicitly necessary because my Windows Live ID is not a @live.com or an @hotmail.com email address), I was able to sync almost everything, including the folders I copied from my giant PST file, via hotmail to both my desktop and phone Outlook. However, there are a few downsides:

• There is an intrinsic delay between when someone sends me an email and when it syncs to any device because Hotmail is polling via POP3. This polling is annoying and sometimes sends me directly to the web mail frontend where I can interact with my personal email directly.
• The Outlook Hotmail Connector sync’ing progress indication is terrible in that it seems to stack every time I press F9 (a bad habit from years of POP3 usage) and I can’t tell what it’s working or or when it will finish. Because of this, I’ve trimmed the set of email folders I sync to the ones I really use, using the PST file as an archive for days gone by.
• Hotmail does the right thing with the “Reply To”, but sometimes weird @hotmail addresses with random characters shows up in email threads, which breaks the fourth wall. That’s annoying.
• My RSS Folders don’t sync to my phone, which is a shame because I really loved having my Hacker News folder pinned to my WP7 home page letting me know where there were new items. None of the RSS readers on WP7 seem to work as well as a simple pinned email folder.

The good news is that this all works for free and my relatives continue to have working email. The bad news is that it doesn’t work nearly as well as the Exchange server I’m used to. Hopefully I will be able to revisit this in the future and get it working correctly.

PC Games

I purchase all of my games via Steam now and install them as the mood strikes me. I love being able to reinstall Half-Life 2 or Portal on demand, then blow it away again when I need the hard drive space. Steam is the only viable app store for Windows right now, although I am looking forward to have the Microsoft app store in Windows 8.

Backups

I no longer maintain “backups” in the sense that I can slap in a new HD, boot from a USB stick and have my computer restored in 30 minutes or less (that never worked between WHS and Dell laptops anyway). I’ve had HD problems, of course, but they’re so rare that I no longer care about that scenario. Instead, what I do is keep all of the software that I normally install on a file server (the new job of my WHS box). If the file server goes down, then most of the software I install, i.e. Windows 7, Office and Visual Studio, is available for download via an MSDN Subscription. The rest is easily available from the internet (including Telerik tools and controls!) and I just install it as I need it.

Where Are We?

In order to free myself from any specific PC, I needed to pick a new centralized authority for my data: the cloud. The experience I was after for my PCs was the same one I already have on my phone — if I lose it, I can easily buy a new one, install the apps on demand and connect to the data I already had in Exchange, Hotmail, Skydrive, etc. Now that I’ve moved the rest of my world to Dropbox, I can treat my PCs and tablets like phones, i.e. easily replaceable. It’s not a perfect experience yet, but it’s leaps and bounds ahead of where it was even a few years ago.

Hardware and software comes and goes; data is forever.

I have gotten to do a ton of really great things at Microsoft:

• I got to write a column on WPF and turn that column into not one, but two books.
• I got the excitement for every blog post in the first two years wondering if this was the one that was going to get me fired. (It was close a few times.)
• I got to throw several Developer Conferences (DevCons).
• I got to spin up a completely new community from scratch (“Oslo”).
• I got to stay up all night erasing the word “WinFS” from all of microsoft.com.
• I got to be part of a Microsoft product team from incubation through startup to product and then to kaput.
• I got to get ordained as a minister so that I could marry a PM from the WPF team to a PM on the WCF team as part of the talk I gave with Doug Purdy at the 2008 PDC.
• I got to prepare for that talk with Doug until 4am, then walk back to the hotel, causing people to cross the street to stay away from us. And then I got to give that talk with Doug the next morning right after restoring my copy of Windows that had crashed 30 minutes before.
• I got to drag Lars Wilhelmsen up on stage to read Norwegian from the Oslo Tour Guide book, only to find I was pointing him at German.
• I got to throw an SDR.
• I got to play poker with Microsoft power brokers far above my level (and take their money : ).
• I got to sleep at Don Box’s house and become an adjunct part of his family.
• I got to have two design reviews with Bill Gates (as hard as I tried, I could never see him actually enter the room).
• I got to turn developer feedback into hundreds of bugs across dozens of products.
• I got code into Vista (and I assume into Windows 7 and Windows 8 as well).
• I got to work on the team that built the most ambitious set of templates ever shipped with Visual Studio.
• I got a very quick, very deep education on JavaScript and CSS.
• I got to help drive the developer story for an entirely new platform: WinRT, WinJS and Win8.
• I got to lead two product teams through two PDCs (OK, one PDC and one //build/).
• I got to give the //build/ keynote launching the Visual Studio 11 tools for Windows 8 with Kieran Mockford, who will forever be my //build/ buddy.
• I got to see how the sausage is made for SQL Server, WCF, WPF, Silverlight, Windows Phone 7, Windows 8 and a host of others. I am forever changed.

Those and dozens more have all been extraordinary experiences that have made my time at Microsoft extremely valuable. But, like all good things, that time has come to an end.

And now I’m very much looking forward to my new job at Telerik!

Telerik is an award-winning developer tools, UI controls and content management tools company. They’re well-known in the community not only for their top-notch tools and controls, but also for their sponsorship of community events and their free and open source projects. Telerik is a company that cares about making developer’s lives better and I’m honored that they chose me as part of their management overhead. : )

My division will be responsible for a number of UI control sets — including WinForms, WPF, Silverlight and ASP.NET — as well as a number of tools — including the Just line, OpenAccess ORM and Telerik Reporting. I’m already familiar with Telerik’s famous controls and am now ramping up on the tools (I have been coding with JustCode recently and I like it). My team is responsible for making sure that developers can make the most of existing platforms, knowing that when you’re ready for the next platform, we’ll be there ready for you.

These controls are already great (as is the customer support — holy cow!), so it’ll be my job to help figure out how we should think about new platforms (like Windows 8) and about new directions.

And if you’ve read this far, I’m going to ask for your help.

I’m going to be speaking at user groups and conferences and blogging and in general interacting with the community at lot more than I’ve gotten to do over the last 12 months. As I do that, please let me know what you like about Telerik’s products and what you don’t like, what we should do more of and what new things we should be doing. Telerik already has forums, online customer support, blog posts and voting — you should keep using those. In addition:

Feel free to reach out to me directly about Telerik products.

Of course, I can’t guarantee that I’ll take every idea, but I can guarantee that I’ll consider every one of them that I think will improve the developer experience. I got some really good advice when I first arrived at Microsoft: “Make sure that you have an agenda.” The idea is that it’s very easy to get sucked into Microsoft and forget why you’re there or what you care about. My agenda then and now is the same:

Make developers’ lives better.

That’s what I tried to do at Intel, DevelopMentor and Microsoft and that’s what I’m going to try to do at Telerik. Thanks, Telerik for giving me a new home; I can’t wait to be there.

I can’t imagine anyone reading this blog needs to read this, but I can’t help myself.

When I was just a wee lad, probably the most valuable thing I learned was how to perform mathematical estimation, the importance of which and several techniques you can get by reading Jon Bentley’s The Back of the Envelope (this essay along with several others, are collected in his most excellent books Programming Pearls and More Programming Pearls, both of which are still relevant a decade later). Not only is estimation generally quicker than running a calculator, but even when you do run a calculator, it helps you figure out when you did it wrong, the latter of which has saved my bacon time and again.

For example, as much as I love the Windows Phone 7 marketplace and it’s quality and quantity of applications, the ones that puzzle me are the “tip calculator” apps (several!). I don’t understand why it’s worth the trouble of pulling out your phone and punching buttons when you can know the tip instantly.

For example, let’s assume the dinner bill is $37.42. If the service was bad, that’s a 10% tip (you have to tip them something ’cuz the IRS assumes you will and taxes them accordingly — bastards). So, with a 10% tip, take the bill and move it right one decimal point: $3.74. Now, round up or down depending on how bad the service was, e.g. $3.50 or $4. Quick and easy.

Assuming the service was great, that’s a 20% tip, so double the bill and move it right one decimal point, making the math easier for yourself, e.g. $37.42 is close to $35, doubling is $70, so a $7 tip. Boom: 20% tip.

If you want to get fancy and provide a 15% tip for good but not great, then average the two numbers: ($4 + $7)/2 = $5.50. Zim zam zoom.

Honestly, as great as the apps are on your phone, tablet or BlueTooth headset (seriously), think about using the apps in your head first. Now only are they quicker and cheaper, but using them staves off dementia (which is a good thing!).

Oh, and if the tip is added as a mandatory minimum, then the additional tip is easy: $0.00. I don’t deal well with authority.

At Microsoft, there’s this passive-aggressive cultural thing called a “forcing function,” which, to put it crudely, is an engineering way for us to control the behavior of others. The idea is that you set up something to happen, like a meeting or an event, that will “force” a person or group to do something that you want them to do.

For example, if someone won’t answer your email, you can set up a meeting on their calendar. Since Microsoft is a meeting-oriented culture (even though we all hate them), a ’softie will be very reticent to decline your meeting request. So, they have a choice — they can attend your meeting so that they can answer your question in person or they can answer your email and get that time back in their lives. This kind of forcing function can take larger forms as well. I can’t say that our execs make the decision like this (since they don’t talk to me : ), but it is the case that signing up a large number of Microsoft employees to host and speak at important industry events does have the effect of making us get together to ensure that our technologies and our descriptions of those technologies holds together (well, holds together better than they would otherwise : ).

Unfortunately, this way of thinking has become so much a part of me that I’ve started to use it on my family (which they very much do not like). Worse, I use it on myself.

For example, I have been holding back on half a dozen or more blog posts until I have the software set up on my newly minted web site to handle blog posts in a modern way, namely via Windows Live Writer. In other words, I was using the pressure inherent in the build up of blogging topics to motivate me to build the support I wanted into sellsbrothers.com to have a secure blogging endpoint for WLW. Before I moved all my content into a database, I could just pull up FrontPage/Expression Web and type into static HTML. Now that everything is data-driven, however, the content for my posts are just rows in a database. As much as I love SQL Server Management Studio, it doesn’t yet have HTML editing support that I consider adequate. Further, getting images into my database was very definitely a programming task not handled by existing tools that I was familiar with.

So, this is the first post using my new WLW support and I’m damn proud of it. It was work that I did with Kent Sharkey, a close friend of mine that most resembles Eeyore in temperament and facial expressions, and that just made it all the more fun!

Anyway, I’m happy with the results of my forcing function and I’ll post the code and all the details ASAP, but I just wanted to apologize for my relative silence on this blog and that things should get better RSN. XXOO.

P.S. I’m loving Windows Live Writer 11!

My mobile device is driving me crazy.

I have an iPhone 4.0. Normally when it’s driving me crazy, it’s standard stuff like the battery life sucks or that the iOS 4.0.1 update didn’t fix the proximity detection or stop emails I send via Exchange from just disappearing into the ether.

This time, it’s something else and I can’t blame the iPhone; I think all modern smart phones have the same problem. The problem is that I constantly have to switch between apps to see my messages. Here are screenshots for 5 of the messaging clients I use reguarly:

This list doesn’t include real-time messages like IM, or notifications like Twitter or RSS. I’m just talking about plain ol’ async messaging. We used to think of it as “email,” but really voicemail, email, SMS, MMS, Facebook messages and Twitter Direct Messages are all the same — they are meant to queue up until you get to them.

Now, some folks would argue that SMS/MMS aren’t meant to be queued; they’re meant to be seen and handled immediately. Personally, I find it annoying that there is a pop-up for every single text or media messages I get on my phone and there seems to be no way to turn that off. On the other hand, if I want that to happen for other types of messages, e.g. voicemail, I can find no way to turn it on even if I want to. Why are text messages special, especially since most mobile clients let you get over the 160 character limit and will just send them one after the other for you anyway?

iOS 4 takes a step in the right direction with the “universal” inbox:

Here I’ve got a great UI for getting to all my email messages at once, but why can’t it handle all my messages instead?

Not only would this put all my messages in one place at one time, but it would unify up the UI and preferences across the various messaging sources. Do you want your text messages to quietly queue up like email? Done. Do you want your voicemail to pop to the front like an SMS? Done. Do you want the same swipe-to-delete gestures on your voicemail as you have with your email? Done!

Maybe someone with some experience on the new Windows Phone 7 can tell me that there is a “messaging” hub that manages all this for me. Since they’re already doing things like bringing facebook pictures into the “pictures” hub (or whatever they call it), that doesn’t seem completely out of the realm of possibility. If that’s the case, I’ll say again what I’ve been saying for a while — I can’t wait for my Windows Phone 7!

I went to a college planning sessions at my sons’ high school not because I’m hung up on getting my Sophomore into a top school, but because I thought I’d get a jump on things. I learned I was actually behind.

For one, I learned that the high school has an online system that will do some amazing things:

• It will give my son a personality test and an interest test.
• From those tests, it will tell him what kinds of careers he might want to consider.
• Based on those careers, what major should he have.
• From the major, what schools around the country offer it.
• In those schools, what the entrance requirements are.

That means that my son can answer questions about personality and interests and draw a straight line through to what he needs to do to get into a school so he can learn to do the jobs he’ll like and be good at. Holy cow. We didn’t have anything like that when I was a kid.

Further, the online system has two complete SAT and ACT tests in it, so, along with the PSAT that he’s already taking, he can do a practice ACT, figure out which test he’s best at (my 34 ACT score was way better than my 1240 SATs) and just take that test, since most schools these days take both SAT or ACT results.

This is all freely provided by the high school and, in fact, they have counseling sessions with the students at each grade level for them to get the most from this system.

It’s no wonder that 93% of students from this high school go on to 4 or 2-year college degree programs.

That was the good part.

The scary part is that my eldest, half way through his Sophomore year, is essentially half-way through his high school career. Colleges only see their grades through the end of Junior year, since most college applications are due in the middle of January of their Senior year at the latest. I have to sit down with my son and have the conversation about how “even if you get a 4.0 from now on, the best grades you can have are…”

Is it just me or is the world moving faster with each passing day?

I’ve been futzing with the site and I’ve got more to do, so unexpected things may happen. Last weekend I screwed with the RSS generator and that caused a bunch of folks to see RSS entries again. This weekend I’m moving more of my static content into the database, so you may see a bunch of old stuff pop up.

Feel free to drop me a line if you see anything you think needs fixing. Thanks for your patience.

It had been a long, hard week at work. I had my feet up when a friend called and popped the question: “Do you know how to build web sites?”

That was about a month ago and, after swearing to her that I spent my days helping other people build their web sites, so I should oughta know a thing or two about how to build one for her. After some very gentle requirements gathering (you don’t want a bad customer experience with a friend!), I set about designing and building bestcakebites.com, a real-world e-commerce site.

She didn’t need a ton of features, just some standard stuff:

·        Built on a technology I already knew so I could have the control I needed.

·        Listing a dozen or so products with pictures and descriptions.

·        A shopping cart along with, ideally, an account system so folks could check their order status or reorder easily.

·        Shipping, handling and tax calculation.

·        Taking payment.

·        Sending email notifications of successful orders to both the customer and the proprietor.

As it turns out, there are a bunch of ways to skin this particular cat, but because I was a busy fellow with a more-than-full-time job and a book I’m supposed to be writing, instead of falling prey to my engineering instinct to write my own website from scratch, I decided to see what was out there.

As it turns out, there’s quite a few e-commerce web site solutions in the world, several of them recommended by PayPal, as well as one that PayPal itself provides, if you don’t mind sending shoppers to their web site. And if fact, I did. Requirement #1 was that I needed complete control over the code and the look and feel of the site. I didn’t want to configure somebody else’s web site and risk going off of her chosen domain name or not being able to tweak that one little thing that meant the difference between #succeed and #fail. (Friend customers are so picky!)

The e-commerce solution I picked was the one I found on http://asp.net (I am a Microsoft employee after all): nopCommerce. It’s an open source solution based on ASP.NET and CSS, which meant that I had complete control when it wasn’t perfect (control I used a few times). It was far more than full-featured enough, including not only a product database, a shopping cart, shipping calculation and payment support, but also categories and manufacturers, blogs, news and forums, which I turned off to keep the web site simple (and to keep the administration cost low). Unexpected features that we ended up liking included product variants (lemon cake bites in sets of 8, 16 and 24 made up three variants, each with their own price, but sharing a description), product reviews, ratings and site-wide search.

The real beauty of nopCommerce, and the thing that has been the biggest boon, was that the whole thing is data-driven from SQL Server. To get started, I ran the template web site that was provided, it detected that it had no database from which to work and created and configured the initial database for me, complete with sample data. Further, not only was it all data-driven based on the products, orders and customers the way you’d expect, but also on the settings for the web site behavior itself.

For example, to get shipping working, I chose from a number of built-in shipping mechanisms, e.g. free, flat rate, UPS, UPSP, FedEx, etc., and plugged in my shipper information (like the user name and password from my free usps.com shipping calculation web service account)

With this configuration in place, the next order the site took, it used that shipper, pulling in the shipping information from the set of size and weight measurements on the ordered products (from the database), calling the web service as it was configured (also from the database) to pull in the set of shipping options from that shipper, e.g. Express Mail, Priority Mail, etc., augmenting the shipping prices with the per product handling changes, and letting the user pick the one they wanted. All I had to do was use the administration console, tag each product with size information and tell nopCommerce that I’d like USPS today, please.

Everything worked this way, including tax calculation, payment options (we chose PayPal Direct and Express so that folks with a credit card never left our site whereas folks with PayPal logged into their account on the familiar paypal.com), localization, whether to enable blogs, news, forums, etc. Most of the time when I wanted to make a change, it was just a matter of flipping the right switch in the database and not touching the code at all.

As one extreme example of where the data-driven nature really came through was on the order numbers generated by the site. During testing, I noticed that our order numbers were monotonically increasing from 1. Having ordered from a competitor’s site, their order number was only 103, clearly showing off what amateurs they were (and the order itself took a month to arrive after two pestering emails, so it was clear how amateur they really were). I didn’t want us to appear like newbies in our order-confirmation emails (which nopCommerce also generated for us), so I found the Nop_Order table, and used SQL to increase the identity column seed, which it was clear was the origin of the order number: 

DBCC CHECKIDENT (Nop_Order, RESEED, 10047)

From then on, every time an order came through, we protected experience simply because of the order number, which I changed without touching a line of code. If helping you “fake it ’til you make it” isn’t enough reason to love a data-driven solution, I don’t know what is!

In my previous list of WP7 user requests, I piled all of my user hopes and dreams for my new WP7 phone (delivery date: who the hell knows) onto the universe as a way to make good things happen. And all that’s fine, but I’m not just a user; like most of my readers, I’m also a developer and have a need to control my phone with code. I have a long list of applications I want to write and an even longer list of applications I want other developers to write for me.

Today at 1:30p is the first public presentations of how to do WP7 programming, so to affect the future, I have to get my feature requests for the Windows Phone 7 Series development environment posted now!

·        I want the legendary Microsoft tools for code editing, UI design, debugging, deployment, version control, add-ins, project management, etc. Please just let me install the “Windows Phone 7 Series SDK” and have Dev10 light up with new project and project item templates et al.

·        I definitely want to be able to write C#. Since Charlie’s mentioned Silverlight, it seems like I’ll be able to do just that.

·        I want to be able to mark a program as useful for background processing, e.g. I’m writing Pandora, and let that trigger a question for the user as to whether to allow it or not, ideally with a message like “Pandora would like to continue to run in the background using XX% of your battery. Is that OK?”

·        For most apps that would like to appear as if they’re running in the background, I want to register a bit of code to run when its own cloud-based notifications comes in, e.g. an new IM or sports score.

·        I want to be able to access data from built-in apps, e.g. contacts, appointments, etc.

·        Obvious things:

o   Notification when the user switches orientation

o   Access to the compass, GPS, network, camera, mic, etc.

o   Access to the network using TCP, HTTP, Atom, AtomPub and OData.

o   Low and high-level access to gestures

o   A nice set of build-in standard controls, including simple things like text box and more complicated things like map and route

o   Integration with existing apps, e.g. the ability to launch the map app from my own app at a specific location or to a specific route.

o   Ability to create custom controls/do custom drawing.

o   Serialization so I can keep user data between sessions. Notifications when my app is being whacked.

o   App-selected keyboards for specific tasks, e.g. entering a URL.

That doesn’t seem like a very big list. I must be missing something. : )

My dear friend Craig Andera posted an implementation of a function that descends into a directory in a “lazy” manner, i.e. you get the first descendant back right away and not after all descendants have been calculated. His implementation was in Clojure, a Lisp variant that runs on the Java VM:

(import [java.io File])

(defn dir-descendants [dir]
  (let [children (.listFiles (File. dir))]
    (lazy-cat
     (map (memfn getPath) (filter (memfn isFile) children))
     (mapcat dir-descendants
      (map (memfn getPath) (filter (memfn isDirectory) children))))))

Craig was happy with this function because, even though it was a “mind-bender to write,” it’s easy to read and because C# “would almost certainly be at least somewhat more verbose.”

Taking this as a challenge, I rewrote this program in C#, maintaining the laziness:

using System.IO;
using System.Collections.Generic;

namespace ConsoleApplication1 {
    class Program {
        static IEnumerable GetDirectoryDecendants(string path) {
            foreach (var file in Directory.GetFiles(path)) { yield return file; }
            foreach (var directory in Directory.GetDirectories(path)) {
                foreach (var file in GetDirectoryDecendants(directory)) { yield return file; }
            }
        }
    }
}

The key hit here is the use of “yield return” which lets me return elements of an IEnumerable as I calculate them. This took me 5 minutes to write, my mind is straight and I find it fairly easy to read. I’ll let you decide on the relative verbosity of each implementation.

When I first moved from the combination of a dumb phone and a separate music player, I had modest requirements: phone calls, MP3 playback, calendar notifications, contact management, email, camera and solitaire. Even asking for only these seven things, my first smart phone was as life changing as my first laptop. I could do a great deal of my work while out and about, allowing me to have a much more productive work/personal life balance.

When I was first married, the word “love” didn’t seem big enough for what I felt for my bride. These days, the word “phone” doesn’t seem nearly big enough for the pocket-sized mobile device that I’m never without, like my wallet and my keys. Further, I expect my phone to replace my wallet and keys any day now, along with the Walkman, DVD player, TV, radio, book shelf, notepads, calculator, compass, alarm clock, wall calendar, newspaper, encyclopedia, dictionary, GameBoy, carpenter’s level, laptop, navigation device and landline it’s already replaced.

Now that I’ve been through several smart phones, including my favorites, the T-Mobile Dash and the iPhone 3G, I have a much longer, incomplete list of what I want from my Windows Phone 7 Series (and I know it’s incomplete because after I post this list, someone is going to remind me what vital things I missed : ).

·        A calculator. It’s surprising how useful this is, including the scientific features.

·        A battery that lasts at least 24 hours while I’m using Bluetooth, 3G, Wi-Fi, GPS, music and my apps. Oh, and please let me charge the thing with a standard connector (USB!) and let me use my phone while it’s recharging.

·        An easy, high-quality way to run the music through my car stereo. The Sells Brothers and I like to jam!

·        An easy way to switch back and forth to airplane mode. Or even better, can you make it so the device isn’t an FAA threat during takeoff and landing so I can stop reading the stupid magazine in the seat pocket in front of me for 5 minutes at the beginning and ending of my flights?

·        Great auto-correct on my hard or soft keyboard entry. This is really the only way that allows my big fingers and the lack of tactile feedback to even work with a phone keyboard.

·        Copy-paste: I can’t live w/o it anymore. Also, please include pasting into my phone during calls so I can stop memorizing 9-digit conference call IDs.

·        I’d really love intelligent integration of music, i.e. keep it playing when I switch apps and not just the built-in Zune player, but 3^rd party music apps, too (aka Pandora). Also, let me pause, next, previous while my phone is locked or I’m in another app. Finally, make sure to stop music when I get a call and start it back up again when my call is over. I love that.

·        Full (!) calendar support:

o   Sync’ing with Exchange and not Exchange.

o   Recognition of phone numbers and addresses in my calendar appointments with links to dial/get directions.

o   Reply All to an appointment so that I can let folks know I’m running late.

o   Snooze on my meeting reminders (I can’t tell you how many times I’ve forgotten my meeting after the one and only 15 minute reminder).

o   Show my appointments on my home page instead of making me dig into some app.

·        Please provide a responsive UI, even if I haven’t rebooted in a week. Ideally I’d never have to reboot at all.

·        Wireless sync’ing to my PC. My house is bathed in Wi-Fi; why make me connect a wire?

·        Tethering so I can use my phone as a network connection for my PC. I’m paying for unlimited data — let me use it! And ideally make that wireless, too.

·        Turn-by-turn directions! This won’t be ready until I go off course and I hear “recalculating” from my phone piped through my car stereo with Pandora playing in the background.

·        There definitely needs to be an “app store” for phone apps, but also there needs to be a way to install apps from other sources without hacking my phone. Also, please let me install them on my SD card so I can take advantage of the extra memory.

·        Let me install extra memory!

·        Let me replace the battery! Batteries go bad over time and they need to be replaced on the go.

·        I need a great audio book listening experience (bookmarks!) and a great ebook reading experience (formats!).

·        I’d like some phone-wide search, including the ability to see where the result came from. I never want the email-only Contact from the list of everyone that I’ve ever received an email from — I want the real contact info that I’ve got cached on my phone.

·        Full contact lookup, both personal and corporate (Exchange).

·        Good camera (and flash): the one on my phone is the only one I ever use, as it’s the one I always have with me.

·        Bluetooth and voice dialing for hands free operation (required by state law in both Washington and Oregon, where I spend most of my time). Also, I’d love the same integration with my Jawbone that I have with my iPhone, i.e. volume control and battery indicator.

·        Apps I can’t live without:

o   Evernote: I’m willing to move my data into OneNote so long as I can sync between the web, my phone and my PC.

o   Social networking clients: IM, Twitter, an RSS/ATOM Feed Reader, YouTube and Facebook.

o   Converter for currency, distance, volume, etc.

o   A Compass.

o   A Flashlight. I have used the ambient life from my phone to get myself out of the forest in pitch blackness. Without it, I’m sure I would’ve been hacked to pieces by Jason or Michael Meyers.

o   TripIt, Movies, OpenTable, UrbanSpoon, Mint: I use these all the time.

o   Shazam: Before this app, I used to record snippets of songs and email them to my son would be charge me $.50/ea. to find the title and artist so I could grab them for my phone. Shazam has cut out the middle man and represents ~100% of the music I purchase these days.

o   Skype or some other good way to use my phone to do IP Telephony (or even IP Video Conferencing)

o   Tetris! I guess there are other casual games in the world, but that’s mine.

Because the WP7 hasn’t shipped yet, I can pile all of my hopes and dreams on it and, like everyone else not on the WP7 team, I have very little idea of whether my hopes will be fulfilled, but that doesn’t stop me from dreaming. So now it’s your turn — what did I miss? : )

P.S. I know that lots of phones have a subset of these features and I’m sure someone will tell me that, with the correct config, I can make their favorite phone do all these things. I know that’s going to happen because whenever I complain about a missing feature in the Visual Studio editor, some emacs guy says, “Oh, you can do that with Alt+Shift+Left Elbow in my editor!” I don’t care about what your phone can do. No phone’s UI has stirred me like the WP7’s UI. That’s the one I want to use, so that’s the phone I’m going to bang on ’til my incomplete list is complete.

When I was but a wee lad, I learned that when it came to my computer, I was often going to be waiting on something, whether it was the CPU, the IO or the memory. Now that I’m all grown up and spending a great deal of time on handheld mobile devices, I’ve discovered a whole new thing I’m waiting on: charging the battery.

In the bad old days of DOS, I spent a disturbing amount of time working on my autoexec.bat and config.sys files to optimize the loading of drivers and TSRs (DOS programs that run in the background for you whippersnappers). Now, instead of optimizing for memory usage on my PC,  I spend my time optimizing for power consumption on my phone, e.g. turning off 3G and Bluetooth when I don’t need them, turning down the polling frequency on my SMTP mail accounts and spreading power adapters everywhere in my world where I sit for more than 5 minutes. The single most important feature on my phone is that’s it’s on and the way power is managed on my iPhone means that this is often not the case. Sometimes I pine for my Windows Mobile Dash for just that reason; it ran for days instead of hours.

And as bad as this power situation is, it would be even worse if my phone ran more than one app at a time. I don’t worry about random apps from the AppStore using too much memory or crashing; I worry about them eating my battery and killing my iPhone in the middle of a route to somewhere I’ve never been. By not allowing background apps to run, Apple is trying to do the right thing but (although my battery life still sucks). I don’t have personal experience with Google phones, but since they do allow background apps to run, I have to imagine battery life is an even bigger problem.

So, when I see people lobbying for background apps on the new Windows Phone 7 Series, all I can say is, you don’t want it. What you want is for work to go on in the background for you without the cost in power.

Oh, I want to listen to my MP3s or Pandora while I answer my email like everyone else, but I don’t want every financial/IM/email/social/sports app I download sucking down my battery life because it feels itself to be more important than everything else on my phone. I want those apps to notify me when something I care about happens but I don’t want the processing to discover such events to happen on my phone - I want the processing to happen in the cloud.

You may recall my piece about how important storage in the cloud is for moble devices. Let’s let somebody else scale and manage the storage so we can leverage it. In the same way, we want to leverage CPU and power in the cloud, saving local resources for cool graphics, twitch games and streaming my “Pink” channel.

Of course, if we’re going to push the processing to the cloud, I’m going to need an efficient and easy way to write my WP7 apps to be notified so I can do the actual processing that needs to happen on the phone. And that all needs to happen while I’m navigating and playing my bad girls party mix.

I’m saving my WP7 phone battery for important things after all.

Reading about Windows Azure Drive reminded me of a conversation I had when I was hanging out with my Microsoft brethren last week. We started by talking about how apps target a particular OS and how Microsoft’s bread-and-butter is making sure that apps continue to work forever on Windows so that our customers can upgrade their OS and still get their work done.

We then moved on to wondering whether Apple was gonna do the same thing when it came to letting iPhone/iPod Touch apps run on the new iPad. As it turns out, we heard from the iPad announcement that Apple is doing just that (although in a particularly strange single-tasking way).

From there we moved on to how it’s really not a big deal whether you ditch your current smart phone, e.g. Dash, iPhone, BlackBerry, Droid, etc., for another one because nobody really keeps data on their phones anymore anyway. It’s either synch’d to their PC, e.g. photos, music, etc., or it’s kept in the cloud. In fact, without realizing it, I already have a great deal of info in the cloud:

• Exchange: email, contacts, appointments
• TweetDeck: twitter search terms
• Evernote: random notes
• Amazon: Kindle books
• TripIt: trip itineraries
• Mint: account and budget information
• Facebook: social contacts
• LinkedIn: business contacts

Further, I could keep my pictures in Flickr, my documents on Live and I’m sure there are many, many more. This is fabulous, because I can move from platform to platform on my phone and it’s in a vendor’s interest to make sure that each major platform has their app on it and because it’s a smaller, more focused platform, it’s easier for them to do.

The problem here, of course, is that we’ve moved from mobile vendor lock-in to cloud data storage lock-in. What happens when Amazon decides to repossess another book or Mint decides to start charging or Flickr goes out of business? Unlike the physical storage business (you know, little garages where people keep stuff when their relatives die or they’re going through a divorce), the logical storage business doesn’t have any legal responsibility to keep the doors open for 30 days when they go out of business to let me move my stuff somewhere else.

And this has already happened. When GeoCities went out of business, all of those people’s web sites were gone. When live.com decided to clean out my set of RSS feeds, there wasn’t any notification or recourse. I’m sure there are more similar stories and there will be lots more in the future.

And because I know there will be more, I’m worried.

Right now, as we move our apps and storage in the cloud, we have a very different dynamic then apps and storage on the desktop. Because apps on the desktop use storage I own, I can back up that data, import it into other programs and, if I feel like it, write programs against it. It’s my data. The vendor doesn’t ever even see it, let alone gate my access to it.

On the other hand, cloud app vendors ARE gating access to my data; I have to use their apps to get to it. Unless there’s some pressure, you can be damned sure the Flickrs and Mints and Amazons aren’t going to be giving up the data they’ve got a wall around now so that I can take it to a competitor.

Which is why we need control over the storage for cloud apps just as much as we do for desktop apps. I want to go to a vendor I trust, e.g. Amazon, Microsoft, GE, i.e. someone big, someone you know is gonna be around for a while, and purchase cloud storage from them. I want to be able to use it as a HD for my desktop data (like Azure Drive and other products before it), including general-purpose backup, but I also want my cloud apps to store their data there, too. That way, if they start charging or they go out of business or I want to go somewhere else with my data, I can do so.

I expect to pay for this service, of course. That way, the cloud storage folks make money, the cloud apps folks make money for using my cloud storage and I get peace of mind knowing that I’ll always have access to my data, no matter what happens to the cloud app or the cloud app vendor, just like today.

We need cloud apps to use cloud drives. Call your congressman!

And here’s one more from the paper file I’m putting into electronic format to reduce the pile of papers in my life:

During the all-associate broadcast, Jerre Stead shared with the team a memo another associate had sent about defining a customer. Here are the highlights:

• Customers are individual companies with unique needs.
• Customers are struggling with their competitors for success.
• Customers are people with feelings and opinions, therefore relationships and experiences matter.
• Customers will judge us by our performance, not by our words.
• Customers are influenced by every contact with us, each and every day.

Customer “Must Not’s”

• We must not import our products or ideas on customers.
• We must not ask customers to deal with people who cannot make decisions.
• We must not make customers wrestle with our bureaucracy.
• We must not allow any question, issue or awkwardness go unattended or unresolved.
• We must never unpleasantly surprise our customer.
• We must never, never take a customer for granted.

Customer “Can’s”

• We can help the customer succeed - make our customers winners.
• We can provide greater value to our customers than our competitors can.
• We can measure ourselves from the viewpoint of our customers.
• We can put decision-making close to our customers.
• We can continuously improve to better serve our customers.

When I was first in technical phone support for the software I was building, I found out that I wasn’t exactly a… um… “natural” at putting customers at ease. I used the following information from an AT&T magazine (I was working for a AT&T VAR at the time) in the fall of 1992 to start my education:

1. Don’t react. Stay calm. When confronted with an irate caller, everyone has the urge to return fire. But don’t fight back. And don’t take it personally, or you’ll become an emotional basket case. Keep relaxed by breathing deeply. And remind yourself that this discussion will not change the destiny of mankind.
2. Let them vent. Remember, you simply cannot get customers to deal with the logic of a situation until you’ve dealt with their emotions. Trying to attack the problem before people have fully vented their anger or disappointment just won’t work.
3. Defusing the anger. When a tirade is winding down, try asking - sincerely - “Is there anything else?” By this point, they’re usually exhausted and willing to talk. If you hear profanity, try saying: “I know the words you’re using right now aren’t directed at me personally.” If the caller replies, “Oh yes they are!” you’re no worse off than you were. But generally they’ll apologize, realizing it’s not your fault. At which point, a real dialogue can begin.
4. What do they want? Once they’ve calmed down, that’s the time to find out what they want: Money back? A defective part replaced? Find out quickly to determine whether you can solve the problem on the spot.
5. What can they have. Once you’ve figured out what they want, what can you do? This will be set by bounds of your company’s policies - such as warranties or guarantees - as well as any flexibility that management may give you (which should be clearly spelled out).
6. Customer solutions. Sometimes, the best solution you can deliver is one the customer suggests. And, surprisingly, it can end up being less than what you yourself were willing to offer. Recently, at a major department store, a customer wanted a discounting an imperfect blouse. The cashier was willing to take 35% off the marked price, but first asked the woman what discount she wanted. The answer: 20% off. Of course, some customers will make outrageous demands. In that case, ask them what they’d consider to be a “fair solution.” Instead of confronting the customer, this reply opens up the discussion to a more equitable resolution.
7. Follow up. Don’t make an angry customer even angrier by not doing what you said you’d do. When a promise is made, keep following up internally to be certain that what was promised has been implemented. Even if that means making a minor pest of yourself!

Fred Gleek

The boys and I were driving past a church with a holiday bizarre, so we stopped by. It was a mix of silent auction, bake sale and a $1 raffle for a turkey dinner with all the fixings. I made several comments about how they could skip the formality of the drawing and to make sure they could read my phone number on the back of my raffle ticket, because I was obviously going to win. They laughed.

When they called this morning to let me know that I had won, they told me that they remembered me and I laughed.

Anyway, the Sells Brothers and I have already picked up all we need for our Thanksgiving dinner, so if you know of a family in the Portland metro area without the means for a traditional dinner this holiday season, please let me know. I doubt it’ll be so big that I’ll need a sled to cart it through the streets, but I’m happy to deliver it when it needs to go. You can leave a comment on this post or drop me a line.

Happy holidays, everyone.

Ever since Chris Anderson built his blogging software and shared it with his colleagues, more and more Microsoft employees has been pushing hard on being as transparent to our customers as we can be. This has been a very much grass roots effort. I remember coming into Microsoft six years ago just when legal was busy giving everyone disclaimers to put on their personal blogs and telling us what we could and could not say. It was always a worry whether the next blog post would get you fired. I got in trouble personally several times, but the brave pioneers before me laid the groundwork for people like me to comment on the internals of Microsoft culture, for Robert Scoble to call Steve Balmer out onto the carpet several times and for Rory Blyth to talk about penises, all on the Microsoft dime. Now blogging is just an accepted way to do things. It’s not even questioned anymore; it’s expected.

And by and large, this transparency is good for reasons that are obvious these days — when our customers see how the sausage is made and have a say in the ingredients, they’re happier eating it with their breakfasts.

As with all good things, however, these is a downside. For example, the product I’ve been working on for 4.5 years has gone through many transformations. This has to do with how new software is designed at Microsoft.

The tag line when we’re hiring folks is always, “Don’t you want to change the world?!” Of course, everyone does and that’s good, because people coming in the door want to take big risks and do big things. If you’re trying for the next Office or Windows, that’s the kind of thinking you need. However, what that means is that we have a lot of folks building 1.0 software. We do this in my division with an organizational structure called an “incubation.”

My product was in incubation mode for years and we started with zero assumptions. My first day on the job, I was asked to “think about synchronization.” What did that mean? What problem was I trying to solve? Does replication count as synchronization? Does data import? I struggled with this for months before I got my head around the process of noodling with a technology enough to understand what problems there were in the space and how that fit with our general idea of what we might want to build into a product.

We tried a huge amount of stuff, often rebuilding shipping technologies to which we had ready source code access just so we could get a feel for how it worked (I personally built multiple data synchronization engines, a WPF-compatible XAML parser, a data binding engine and a set of universal data viewers during that period, all of which were thrown away, as expected).

As we got further along, we started producing things that needed to be published, even if they weren’t a core part of our product anymore (like MEF and some new features in XAML 4.0). Once this started happening, we started to feel like we had a handle on what we were doing to move into “startup” mode, where we formed a team to make productization plans. At this point, we started telling folks what we thought we had, including analysts and “insider” customers, getting their feedback. Based on this feedback, we re-jiggered the product and the story and did it again. And again.

Eventually, we move out of startup mode to become a real product team with dev, test, PM and UA splits (up ’til then everyone does everything or, as we liked to say, “everyone shovels”). Eventually in this mode, you publish some set of bits that are your best guess at the time of what we think we’re eventually going to ship. In our case, it was the October 2008 “Oslo” SDK CTP, guaranteed only to take up space on your hard drive. At the time, we’d been telling the “Oslo” story for more than a year and it had evolved a great deal. Since we published that initial CTP, we’ve published a few more, along with an entire web site filled with articles, videos, specifications, samples, etc.

I mean, we did it big. We were part of the keynote at the 2008 PDC and we had lots of folks on our team that are very visible in the community, including Don Box, Chris Anderson and Doug Purdy. These are the heavy hitters, so when they said something, folks listened.

And we definitely got a lot of community involvement — way more than we expected, in fact. With that involvement, we got a ton of feedback, which is the benefit to us of releasing early and often. We take that feedback and we make changes to our product — sometimes big changes. In this particular case, we were building on all kinds of SQL Server-related technologies, so because of pressure to build the absolute best thing we possibly could for our customers, we actually merged the division that owned “Oslo” (and WF, AD, WCF, BizTalk, etc) with the SQL Server division.

Of course, those are the kinds of changes that our customers don’t see. What they see is that things are changing and that they’re not quite sure what our plans are. That’s one big downside:

When you share early information, sometimes it’s half-baked, it often changes and is almost always confusing.

As an example, Jeremy Miller recently had this to say about “Oslo” and our communication about it’s purpose in life. Believe it or not, this is helpful feedback and it’s my team’s responsibility to understand what exactly is holding folks up and get it fixed in the way we tell the story and in the product itself.

Another part of my team’s responsibility, of course, is communicating what it is the product does so that folks can understand it and give us feedback. That means that the first people that know how confusing a product is are the folks writing the documentation and tutorials, building the videos and producing the samples. And believe me, we act as customers on the team as well, logging bugs and making complaints and bugging the developers and PMs directly, hoping to fix everything before customers even see it. Of course, we can’t do that all the time (or even most of the time), so often:

We produce materials that tell the story in the very best way we know how with the current set of bits.

Kraig’s recent “Oslo” blog post is an example of this. This is an important part of the process, too, actually. We, as Microsoft employees, can complain to the folks producing the software ’til we’re blue in the face, but often real changes aren’t made ’til real customers complain. As a consequence of this:

We take the slings and arrows of our customers and thank them for taking the time to shoot us.

This one can really hurt, actually. I’m a professional, but I take it personally when I say something that doesn’t resonate with my audience (at a recent conference, I threw away an entire completed slide deck and started over only days before the deadline so I could tell a better story) and the audience takes it personally when I show them something that they don’t understand.

In fact, everyone in marketing, DPE, UA and every part of the team that interacts with customers directly or via the software we’re producing, including the devs and test engineers, all take it personally. We care deeply about building products that delight and empower our customers, which is why we push so hard on transparency from the bottom — the sooner we hear your complaints, no matter how confusing we might be, the better able we are to build something you love.

I’ll tell you though, if we could build something you’d love without giving you an early look, we might want to do that because:

When a customer is confused or disappointed by an early look at a product, they might not want to look at it again for a really long time, if at all.

Early looks are a double-edged sword. We want the early feedback to make our product better, but if you don’t come to look at it again, you’ll never know we made it better.

Still, transparency is absolutely worth the downsides. Keeps those cards and letters comin’! : )

I’ve picked up PowerShell half a dozen times or more. The central premise, that I can pipe streams of objects instead of streams of text between programs, is pure genius. However, in the day-to-day, two things make me put it down again every single time:

1. The differences between ps and cmd.exe are annoying and unnecessary.
2. The lack of pushing the boundaries on the text output in a GUI window leaves me wondering what I really gain when I get over the hump of #1.

I understand the need to “reboot” the DOS command line and get something scalable and consistent, but ps is a superset of cmd.exe and aliasing could’ve made the transition seamless. However, because little more than “dir” works (and “dir /s” doesn’t) I’m constantly bumping into barriers just trying to get my work done in the new shell.

And I’d be really ready to learn ps, especially since it’s everywhere now, but what am I really gaining? I never wrote a bunch of shell scripts in cmd.exe and I don’t find myself writing them in ps either, which means that the cool “piping objects” thing doesn’t make my life any simpler. What I really really want is for the text window of the ps shell to also be something active, e.g. if I do a “dir”, I’d like to be able to click on a file or folder in output of dir and open it or right-click on a file and choose a method on the .NET File object to execute. Even better, I’d like all of that functionality but with a keyboard command interface like the old Norton Commander used to provide. I’ve tried the ps IDEs and GUI shells and haven’t liked any of them.

Anyway, the first thing that’s made me really really want to move to ps is PowerBoots! It’s starting to really deliver on what I had hoped to get out of ps and it feels like Shoes, which I already know I love. Check it out!

I saw Nick Muhonen give a talk on the new language features in C# 4.0 last night at the Portland-Area .NET User Group. He did a good job in spite of the constant questions I asked. He showed one example that I found especially compelling:

object GetConfig() {
  return new {
    WindowSize = new Size() { Width = 100, Height = 200 },
    ConnectionString = "...",
    ...
  };
}

Of course, you wouldn’t hard code settings in your application — you’d load them from somewhere (ideally a database, but that’s another story : ). Anyway, in C# 4.0, I can write code like this:

dynamic config = GetConfig();
mainWindow.Size = config.WindowSize;
...

Notice the use of the dynamic keyword — this means I don’t have to know the type at compile-type — I’ll check for the WindowSize property at run-time ala .NET Reflection, COM IDispatch or VB “Option Explicit Off”. Of course, this is the cornerstone of all dynamic languages, e.g. Perl, Python, Ruby, etc. These languages have been gaining in popularity for the last few years and I didn’t understand why. Tim Ewald, my close friend and compadre, kept trying to explain it to me, but I’m just too slow to get it and I didn’t ’’til last night watch Nick do his thing. It wasn’t looking at the code that Nick typed that made the point for me, it was looking at what he didn’t type.

When writing dynamic code, there is no requirement to define a type.

That is, when I inevitably add another property or 10 to my app config, I have to write code to use the new properties, but that’s all. I don’t have to write a class and I likely don’t have to update the save/load code either, because it’s also going to be dynamic and just expose whatever data is part of the serialized config. Or, to put it another way:

When writing dynamic code, I only have to write the part I care about.

In the case of dealing with application config, that’s about 2/3rds of the code I no longer have to write. Of course, this isn’t a new idea — Stuart Halloway has been talking about embracing essence (the code you care about) and rejecting ceremony (the code you don’t) for a long time now. It just took Nick’s concrete example for me to understand it.

And not only does this make dynamic code good for reducing the code you type, it always makes it good for the code you’re generating, e.g. COM interop assemblies, database mapping code, XML mapping code, etc. In general, I find that most of the code we have generated for us in the .NET programming environment is code to map to foreign type systems, i.e. COM, databases, XML, web services, etc. With dynamic languages, you can write that code once and just use it. In fact, in C# 4.0, there’s no need to use Primary Interop Assemblies (PIAs) anymore — those can just be mapped to a sub-class of the “DynamicObject” type that .NET 4.0 ships to provide that dynamic mapping bridge.

When writing dynamic code, you don’t need generated code layers to map to foreign type systems.

This means I don’t have to do the mapping to databases per query or to XML per XSD — I can just have an implementation of DynamicObject, point it at my configuration and go — no muss, no fuss. Of course, purely dynamic languages have a construct for DO built right in, so it’s even easier.

Around the table after Nick’s talk last night, someone was complaining that with purely dynamic languages, I give up the benefits of the compiler doing static type checking (I think it was Nick : ). I argued that this was a good thing. The compiler is really just one kind of unit testing — it’s testing names. It can’t do any of the other unit testing you need done, however, so you still need unit tests. What that means is that, with static languages, you’ve got some unit tests separate from your code and some baked into the code via types, casts, etc.

When writing dynamic code, you can separate unit tests completely out of your code.

Of course, as software engineers, we already know that separating concerns leads to better, more readable and more maintainable code, which is why we’ve long separated our applications into tiers, separated our view from our data, our interfaces from our implementations, etc. Dynamic languages let us do another complete separation of concerns with regards to unit tests that static languages don’t allow. In a static language, the ceremony is required, thereby obfuscating the essence.

And all of this is great except for one question — how do I get my list of possible code to write when I type ”.” if I’m using a dynamic language or dynamic features of a static language ala C# 4.0?

When writing dynamic code, I don’t get Intellisense.

My name is Chris Sells and I’m an Intellisense addict. Admitting I have the problem is the first step…

All my friends have updated to Windows 7. My 14-year old son is running Win7. I’m the only one I know that’s not running Windows 7. The reason? Windows 7 took away a feature I use all the time, as shown on the right: Search the Internet.

Here’s what I do all day, every day in Vista: Ctrl+Esc to bring up the Start menu, then I start typing. If I’m searching on my HD, I immediately get matches and I can choose one with just the arrows and the Enter key. If I’m typing in the name of a program in the Start menu, I get those matches and choose one. If I want “calc” or “notepad” I can just type those and those work.

However, 80% of the time, I want to search the internet, so enter my search term, optionally including attributes like “site:”, I press, down-arrow once, highlight “Search the Internet” and press Enter. This brings up my default browser with my search results in my default search engine without me having to move the mouse or open the browser and wait for the home page or even decide where I want the search results to come from until after I’ve entered my search phrase.

And they took it out of Windows 7. : (

I logged the bug and heard nothing.

Does anyone know of I 3rd party program I can run that will work exactly like the Vista Start menu under Windows 7? Please?

At the last DevCon in 2003, blogging was rampant. We had about 100 posts in the lead up to the conference and during the conference itself.

A this year’s DSL DevCon, there’s a ton of buzz, but almost none of it is in the blogosphere. Instead, it’s all in Twitter.Last I checked, it was more than 150 tweets and we’re still on the first talk of the 2nd day (and day #1 was only a half day).

The worm has turned.

I’ve had an iphone for the last coupla weeks and there are some things that drive me crazy about it!

• The battery life is crazy short. I can’t make it more than 6 hours on a charge. Good lord!
• Pandora, an app I dearly love, can’t run in the background like the ipod app, so I can’t do SMS, email, check my calendar, etc. while I’m listening. Are you kidding me?
• There’s no tactile feedback on the keyboard, although the auto-correct is amazing (“let go, let iphone!“).
• There’s no copy-paste. I’ve never used a smart phone that did, but I soooo want this feature!
• There’s no free out-of-the-box app for using my iphone as a laptop modem, which is something I really loved about my T-Mobile Dash.
• I used to be able to use my T-Mobile account to get free wifi at Starbucks. Can I do the same with my AT&T account? I have the unlimited data option.
• There’s no turn-by-turn directions on the map app and easy re-routing when I go off route. It’s so close; let’s go all the way!

And all of that pales in comparison to the single worst deficiency in the app-suite of the iphone for which I’ve found no good work-arounds; the calendar app is nearly worthless in a business environment:

• There is no snooze, so I can’t set an alert for 15 minutes and then 5 minutes before, then at the time, etc. In a meeting driven environment like Microsoft, the lack of snooze means that I’m actually missing meetings.
• There is no way to invite other people to events. Further, if I create an event via Exchange so I can invite someone, I can’t edit it on the iPhone.
• I can’t do a Reply All to an event to ask a question or let folks know I’m running a little late.
• There is no detection of phone numbers or addresses in event locations or the body, which means I get no integration with the phone or map apps. This means that I’m memorizing phone numbers and addresses stored in events so I can enter them manually. I have a smart phone so I don’t have to remember this stuff!
• My appointments don’t show on the home screen, so I have to constantly check the calendar app to see what my day is going to look like.

The calendar app is the single thing that makes me miss my Dash. Someone please tell me there’s a workaround to these issues! I’ll pay!

The reason I list the things I hate about my iphone is because the list of things I love about it would be impossible to enumerate. I had a T-Mobile Dash for years and it went with me everywhere. It was as big a boost in my electronic lifestyle as my first laptop. After having a smart phone for contacts, email, music and surfing the web, I couldn’t go back. Plus, I loved the Dash so much that I’d try a new phone every 6 months or so and then bring it back because it just didn’t compare.

On the other hand, the iPhone replaced my Dash in 24 hours. I’ve been twittering iPhone development related apps. I’ve purchased iphone charing cables for everywhere in my life where I sit for more than 5 minutes. I want to integrate my iphone as closely into my car as possible.

They will pry my iphone out of my cold dead hands.

Scott Hanselman performed an intervention on me in the mall the other day. I was in denial and while I can’t say I’m fully into acceptance, I’m at least past anger. : )

It took Scott 90 minutes and I fought him every step of the way, but I think I finally have a handle on what Twitter is. I’ve heard it described as a “24-hour virtual cocktail party,” which always turned me off. I’ll take a lake of fire any day over more than three strangers in a room with which I share no common task and with whom I’m expected to socialize. Making that into a 24-hour thing and including everyone in the world does not make this more attractive to me.

And while that is one valid way to describe Twitter, the more attractive way for me to thing about it is as a single global chat room with conventions and tools to pull out the bits and pieces you want, i.e. the people to which you want to listen, the topics you care about, etc.

Except that’s not right, either.

Instead, it’s more like a poetry reading in a hippy bar where you’re up on stage saying whatever comes into your head and the audience is generally ignoring you (because they’re also on their own stage) except occasionally when they holler “yeah man! right on!” back at the stage.

And why is that cool?

Well, I can’t speak for anyone else, but until Scott turned the light on in my head, it wasn’t. Now I check Twitter (via TweetDeck) half a dozen times a day looking for direct messages first, then replies, then new search results (I search on my name, Oslo and DSL right now), then whatever’s on top of my “All Friends.” When I find someone that says something interesting about a topic I like, I follow them for a while til I decide they’re saying mostly stuff I’m not interested in and then I unfollow.

The whole thing feels very much like what we used to do in email (“Look! Cute kiddie pictures!“) and then in blogs (“Look! I have a blog!“) before we figured out how to use it and what it was really for. I can’t say I really know what Twitter is for yet, although I’ve been following Scott’s advice, i.e. bigger, permanent stuff goes into blogs, transient stuff to a few people goes into email and transient stuff that goes to the hippy bar audience (i.e. the world) goes into Twitter.

I’m still very much learning and hardly anyone is following me (@csells), but that’s OK. I’m already finding out who’s in the Oslo community and have had lots of useful stuff on personal topics, too, e.g. sharing my iPhone love/hate.

Also, I have to say that I really love the social aspect — I’m working alone at my house a lot and it’s nice to have the world listening to every fool thing that comes into my head. : )

A few years ago, I looked like the “before” picture to the right. I didn’t look like that all the time, thank goodness — this was some couples’ party and I was doing the “ballerina dance” challenge — but as you can tell, I was a tad overweight. Specifically, I weighed in excess of 100 pounds more than the top end of my idea weight range, which put me over 300 pounds.

I had been a skinny kid with a fast metabolism growing up. At 6′5″ it takes a lot of food to get to full grown, even when I had only a medium build (I can’t even claim to be “big boned”). In college, living in a fraternity served by a cook that believed fully in the benefits of meat and potatoes and having been born in the Midwest with a gravy ladle in my mouth, I got my “freshman 15″ in the first semester and kept on going until I was the jolly fellow you see to your right (complete with the belly that shook like a bowl full of jelly).

I tried dieting. A few years ago, I was able to lose 50 pounds on The Geek Diet (it was a freely downloadable PDF file at the time), but gained it all back in a year. The problem was that that diet is fundamentally based on deprivation: you count calories and don’t eat more than a certain amount based on your activity level. This made me hungry and crabby all the time. Then, one Christmas back in Fargo under the influence of my deep-fried meat, brownie, cinnamon roll and fudge pushing grandmother, I snapped. It was like a psychological rubber band, pulling me right back into my old habits. Also, I didn’t exercise, so I’d plateau’d and my metabolism wasn’t equipped to deal with even a few extra calories.

Over the last twelve months, I tried something different and as of a coupla week ago, I look like the guy on the left. I called it “eat right and exercise.” It sounds revolutionary, I know, but I’ve lost 60 pounds over the last year and I’ve kept it off (even after the visit to my grandfather over the holidays!) The idea isn’t to diet at all, but to change your habits. I can’t say that I’m expert enough to recommend any of this to you, but here’s what I did:

Stop Eating When You’re Full. This was the hardest one to learn. In college, I learned up to drink and, most importantly, when to notice when it’s time to stop drinking. However, it took me ’til I was 38 to learn how to tell when I was full. This involves eating slowly and being very ready to leave food on your plate (which I always try to do now).

There’s Always More Later. This is the other key to stopping eating. As much as I might like something and want to finish it, I had to realize that there would always be more of whatever it was later. I learned to feel good about leaving food uneaten, no matter how good it was.

Eat Better Food. If you have to choose between eating 1000 calories of Doritos or of broccoli, I think we all know the right choice to make. The key is, making it. I’ve had to learn to like salad, fruits and vegetables, which I’m still working on. I’m always trying new things to learn to eat things that are better for me.

Don’t Buy Grazing Food. If I’m doing something I don’t like or am bored or reading or watching TV or any number of other things, I can easily eat chocolate or chips or any other manner of things that are bad for me, even if I’m not hungry. I have a hard time saying “no” to an unhealthy snack when I’m watching a movie, for example, so I don’t buy them. Instead. I buy apples and applesauce and melons and other things that are good for me so that if I have to snack, there are only good things available.

Eat Lots of Meals. This one is counter-intuitive, but I find I do better if I eat a small amount every few hours than larger meals three times a day. In general, if I’m hungry, I eat and if I’m full, I stop. It’s really just that easy.

Don’t Deprive Yourself. If you want a piece of chocolate or a chip or whatever it is that you crave, then have it. Life is short and there is a variety of wonderful things to enjoy. Don’t gorge yourself — everything in motivation — but don’t make yourself crazy, either. I find it makes me feel good to eat a piece or two of my grandmother’s famous fudge and it feels equally good to stop eating it.

Exercise Regularly. This is one of my major failings with The Geek Diet. I was depriving myself of calories, but I wasn’t boosting my metabolism, so my body was just adapting to fewer and fewer calories. These days, I try to swim 2 miles/week and that seems to keep me at my fighting weight.

Mix It Up. I find I’m happiest eating a bunch of small portions than one or two large portions at a meal. I like variety, so I like a little bit of a few things. Also, to make sure that my body doesn’t get used to my level of exercise (it’s getting easier and easier to swim for distance), I try a variety of exercises. For example, I just did a 90 minute hot yoga class the other day (I thought I was gonna die) and I regularly do sprints in the pool, going as fast as I can. The latter’s useful because it always sucks, no matter how fit I get, so it’s almost more than I can handle.

Commit. The key to making anything happen is to decide it’s going to happen and then route around obstacles until it does. The days I swim without resting or swim a mile when I normally go half are the days I decide to do so. The key to weight loss or any other accomplishment is first to commit.

Don’t Beat Yourself Up. Didn’t do as much exercise as you wanted this week? Had a few too many Twinkies? So what. You’re human. Let it go. Don’t give up. Do better today.

The whole point of all this is that it’s not about a temporary diet, but about changing my habits permanently. I still have 40 pounds I’d like to lose, but I don’t obsess about it. In fact, I haven’t weighed myself in months. And even if I never do lose those pounds, I’m down from a 44 waist on my pants to a 38. If I do nothing but stay there, I’ll be happy as hell with myself.

I love that most of these tips are just like Scott’s newsflash — gives me some validation. Do you have tips to contribute? Tell me about them.

So, the other day, Windows XP SP2 destroyed my Windows Media Center Edition install that I’ve been using for years and absolutely loved. It let me record all my favorite shows on two separate tuners and I could watch them on the TV attached to my MCE box, from all the PCs in my house and from my XBOX 360. Losing it was a huge blow, especially since it was clear I’d need to repave and I was swamped with PDC and post-PDC work (damn those MSDN Magazine deadlines!).

A little research revealed the following facts:

• tvrss.net provides RSS feeds of every TV show I’ve ever heard of, whether it’s on normal TV, cable or a premium channel like HBO and Showtime. The shows are available in HD with the commercials pre-edited out, so I wouldn’t even have to do the 30-second fast-forward, 5-second rewind dance that MCE enables to skip them.
• uTorrent provides automatic downloads from RSS feeds, including fancy features like only downloading each new episode once, even if it’s provided from multiple sources.
• My Verison FiOS pipe provides 20MBps downloads, so a 22 minute TV program (30 minutes - 8 minutes of commercials) even at HD would only take about 20 minutes to download, on average.
• My $500 Windows Home Server machine has 1.4TB of storage, so your average 22-minute sitcom, at 180MB, is only a tiny fraction of the storage. Put another way, I could store about 4000 hours of TV.
• My XBOX 360 supports the same format (XVID) that TV shows available from tvrss.net seem to be provided in. Further, my 360 has direct support from playing videos from shares on my home network (which is wired for 1GB Ethernet, but only run by a 100MB Ethernet router right now).
• The XVID codec is available, along with a ton of other useful codecs, from free-codecs.com (I’m partial to the K-Lite Codec Pack myself), which means that any videos that I download in XVID format can be played back on any PC in my house. Those PCs running Vista Ultimate that have a Media Center remote control on them can surf to videos on the network and pick them with an experience just like that of my XBOX 360.
• It’s my understanding that the XBOX 360 menuing system will be updated this month to support Netflix streaming, so for the minimum subscription fee (1 DVD at a time, $8/month), I’ll be able to get live, streaming movies directly from my XBOX 360 and all my PCs for the movies I don’t yet own.

All of this means is that if I were to schedule episodes of say, Burn Notice, to be recorded by uTorrent and dropped into the Videos\TV\Burn Notice folder of my WHS box, I’d be able to access those and play them back on my XBOX 360 even more simply then I could access video from my MCE box, because I don’t have to start up the Media Center software first — access to shared folders is built right into the XBOX 360 menuing system. And I could have all of this in HD (no CableCard required) without commercials and without regard for how many tuners I have. This is all free and, if I don’t want to watch live TV (the Superbowl was the last time I did), then I don’t even need to spend $55/month on cable.

Plus, when combined with my photos, music and ripped DVDs, all of which are also stored on my WHS box, and streaming movies I don’t yet own, I could access all of my digital media from my XBOX 360 (attached to my 46″ LCD panel) and from all of my PCs simply and quickly.

Of course, I would never record my favorite TV programs like this, because it’s very much a copyright violation and therefore highly illegal.

But if I did, wow, it would rock…

Why do I need cable again?

Yesterday, the ASP.NET team announced that they were going to ship jQuery, a small, populate open source web client library. And not only is Microsoft going to ship this library, as is, but we’re going to build support into Visual Studio for it, build future versions of our web components assuming it and support it via PSS like any other Microsoft product.

This is huge.

Of course, is it useful for developers using Microsoft tools, because they get another supported library out of the box for them to use to build their applications. But that’s not what makes it huge.

What makes it huge is that, instead of seeing the functionality in jQuery and thinking to themselves, “Wow. jQuery is really great. Let’s build something from scratch like that into our products,” the ASP.NET team, in what is the first time in Microsoft history afaik, decided to reuse something from the world that was already working, adding only the thing we do better than anyone else: integration into a suite of libraries and tools.

“But isn’t this just ’embrace and extend?’” I hear you asking. “Isn’t Microsoft just going to absorb jQuery, thereby killing it for folks not using Microsoft products?”

There are two ways forward at this point. One, we could push on jQuery in a Microsoft-centric way until the project “owners” (which is a slippery concept with an OSS project anyway), decide to either give up and let Microsoft “own” it or they decide to fork jQuery, thereby creating jQuery-classic and jQuery-MS. This would not be good for the jQuery community.

The other way to go, and this is the way I hope it goes, is that Microsoft learns to play nicely in this world, submitting features, changes and bug fixes to the jQuery source tree in a way that’s consistent with the vision from which jQuery sprang, making it work better for Microsoft customers and non-Microsoft customers alike.

If we can learn to do that second thing, then we’ve turned a corner at Microsoft. I’m keeping my fingers crossed.

I’ve always liked the Mac vs. PC ads. They’re clever, they make me laugh and I like both actors (Accepted is very under rated, IMO). Of course, I actually prefer my PC running Windows to a Macintosh (I had a Mac IIcx back in the day), I prefer Vista to XP and I’m a Microsoft employee, so I don’t have any trouble seeing the exaggeration, but there’s always a kernel of truth, which is what makes them funny. The part that kinda annoys me is that Apple seems to be claiming they have no such problems, which is, of course, not true.

The Mac vs. PC ads I understand: they’re meant to put down the PC by having the PC guy look like an idiot, leaving the Mac guy to seem non-threatening and therefore better by comparison.

On the other hand, I can’t say I understand the latest Windows ad with Jerry and Bill. I did enjoy it, however. Not only did Bill seem much friendlier and more approachable than I’ve ever seen him, but the image of someone in the shower with their shoes and socks on made me laugh, as did the image of Bill wiggling his butt in a Deep Throat sorta way.

And the commercials are having an effect: they’re being talked about and folks are interested in the next one. How often do you hear about folks looking forward to a commercial? That in and of itself is an achievement.

I gave a talk to the Digigirlz yesterday and it was a blast. It was 25 high school girls that were on the Microsoft campus all week learning various technologies to promote women in IT. The girls are nominated by their teachers for aptitude and attitude and these girls had both in spades.

Vijaye Raji and I were giving the talk, me primarily the pretty front man while he drove the slides, typed the code and made sure I didn’t get things very wrong (he knew the environment and the language far better than I). We were teaching general programming basics using a variant of BASIC that was especially well suited to new programmers. We spent two hours showing them how to do turtle graphics and how to write a game (Pong) all from scratch and we all had a blast doing it.

And these girls were sharp! I’m used to pacing material for rooms of adult software engineers, but I didn’t have enough. I had to take feature requests from the audience and figure out how to implement them on the fly while they followed along, programming their own versions of the game as we went. They were hands on the whole time and eventually I enlisted their help to tell us what code to write. Mind you, this was a language they’d only learned minutes before, but they didn’t have any trouble at all.

They laughed and asked questions and answered my questions and were engaged the whole time (well, most of them — some were seduced by the siren song of the high speed internet connection : ). I figured I was doing OK when one of the girls asked me if I ever thought about being a teacher.

“Naw,” I said. “I hate kids…”

They didn’t buy it… : )

When I was a teenager, some kids were sneaking out to get drunk or have sex. I was sneaking into my parents’ record collection to listen to George Carlin. Unfortunately, unleashing my version of his brand of humor on my peers was one of the things that kept me from being invited for parties or sex, but I still dearly loved the man and was very sorry to hear that he passed away yesterday.

Certain situations still trigger George Carlin responses whether I want them to or not; he is permanently lodged in my brain. And of all the things he’s done, his incomplete list of impolite words is stuck in there furthest (*not* safe for work!).

I’ll miss you, George. Give whatever all-powerful being you run into in the next life a piece of your mind about the state they’ve left us in here on Earth.

Update: a very NSFW GC highlight video series.

Today is my last day of time off work from a tonsillectomy a week ago Thursday. I’m down to about 20mg of OxyContin/day (from 60mg) and hope to have that down to nothing by Monday (although I still have half a jug for my next party : ).

Why would a grown man fresh off two SDRs and a BillG review feel the need to have his tonsils pulled? Well, I’ve been trying to talk someone into taking them for a coupla years now, even since the recurring strep throat started, but no luck. This time it was because I wasn’t sleeping properly.

A few months ago at a routine checkup, my doctor was working her way down a standard questionnaire, asking me if I had this problem or that problem. I’d been swimming a lot and had lost a few pounds recently, so mostly I didn’t have any health problems. Until she got to sleep:

“Are you having any trouble sleep?”

“Well, I’ve been waking up about 4am every morning, no matter when I go to bed.”

“Any stress?”

“I work at Microsoft,” I said, figuring that was answer enough.

She laughed. “I mean anything out of the ordinary?”

I couldn’t think of anything that would explain it, so I said so.

“Have you ever had a sleep study?”

“Well, one time I recorded a chapter of my social studies text book and listened to it all night while I slept. I got an A on that test.”

Now she was just tired of my lip, so she explained what she meant. And then she signed me up. And I went. And it sucked. Imagine trying to get sleep while tied up (and not in a good way!).

The diagnosis of my sleep study was “severe sleep apnea,” as defined by more than 10 episodes an hour when I stop breathing and more than 10% decrease in oxygen to my brain. I was at 31 and 17% respectively, the sleep tech told me as they strapped me in for sleep study #2, this time with a C-PAP machine. Now imagine sleeping while being tied up and gagged.

Apparently the gag improved my sleep enough that it “cured” my sleep apnea so, without benefit of advice from an actual sleep doctor yet, I was set up with my own C-PAP machine, where I could gag myself every night before going to sleep. And not just gag myself, but strap on a hockey mask while someone blows into your mouth all night long. And now try to sleep while this is happening. My father got one and complained bitterly about it for a full year ’til he got used to it.

So, being even more stubborn than my father (which, if you knew my father, is stubborn on a Biblical scale), I asked for a second opinion. Or at least a first opinion from an actual sleep doctor (and not just a tech).

And I got one. There are other treatments besides C-PAP machines for sleep apnea, among them tonsillectomy (can work depending on the patient), some kind of dental appliance (generally not very successful) and, I kid you not, learning to play the digeridoo. This last one had me particularly interested as I’ve always wanted to do that anyway. (Come on! Breathing in and out at the same time and making weird noises! It’s like sex without the mess!)

“Well, let’s see if a tonsillectomy would help you,” the doctor said, leaning in for a look down my throat. He shined his little light in and then started backward as if scared. “Oh, yeah… You’ll want to have those looked at,” he said, his eyes all big.

“What?” I asked, a little worried.

“Those are within the range where should talk to an ear-nose-throat doctor about having them removed,” he said, hastily writing out a recommendation and stealing a look at my throat out of the corner of his eye as he did so.

And so I went to the ENT doctor, a young’un one step up from Doogie Howser (or maybe just having celebrated my 39th birthday, everyone is starting to look really young to me…). He explained how things worked inside the mouth and throat. He looked at my nose. He looked in my ears. He understood my dislike of the C-PAP machine. He described the four-point scale they used for measuring tonsils, asked me to open wide and, like the other doctor, started backward after a 500ms look.

“Those are huge!” Doogie said.

“Really?”

“Yeah!” I swear his pupils were dilated in some kind of fight or flight response.

“So, on the four-point scale?”

“4+. Huge!” he said. “Most people have a bunch of space around their tonsils to let he air in. How are you able to breath at all?”

“OK, doc. What do you think we should do?”

“We should take ’em out! Here’s how it’s going to work…” and he started describing the surgery, which was to include removing my tonsils, shaving back my uvula and fixing my deviated septum.

“Will I ever be able to sing?”

“Sure,” he said. “That shouldn’t be a problem.”

“Great. I’ve always wanted to be able to sing!”

He laughed. “Well, no promises there.” And then he started to describe the complications. Up until then, I was fine with him talking about permanent non-trivial surgery to correct a problem that I could be using an external (infernal!) machine to correct otherwise. But when he started talking about “uncontrolled bleeding” and “rushing to the emergency room as [my] stomach filled with blood,” well, that was a bit much after no breakfast that morning.

“Are you OK?” he said, a concerned look on his face. “You’ve gone all white.”

“Ah, no, actually, I’m not. I’m feeling a bit faint…”

So Doogie had me put my head between my knees and breath deeply. And when that didn’t work, he popped some smelling salts under my nose. That hurts! But that didn’t work either.

“Huh. That normally works,” he said, dumbfounded at the giant man getting ready to pass out in his office. “Nurse! Bring me some juice!”

After recovering from the mere idea of uncontrolled bleeding down the back of my throat (which still makes me a little queasy just typing it), he said, “Well, let’s not talk about that any more. You’ll come in and I’ll take care of it, OK?”

That sounded good to me, so I scheduled the surgery for 6/5, a week after the BillG and a few days after my birthday (my own gift to myself : ).

So, I had a few weeks to shutdown my work because the doctor said that I would be out for “at least” two weeks recovering. “And you’ll be on heavy medications, too. Kids bounce back in a day or two, but this is *very* painful surgery for adults.”

Great. Never had any surgery other than my wisdom teeth and now I get a doozy.

I started informing those around me of my impending doom. And then the advice started.

“The first week was really easy. It’s the *second* week that’s hard.”

“My throat hurt so much that I just didn’t eat for two weeks. I lost 30 pounds!”

“Those drugs will lower your IQ by like 30 points.”

“I wonder if your voice will change? Mine did.”

“I had a tonsillectomy as an adult and I still can’t say my Ls properly.”

As a professionally speaker, I didn’t mind the idea of my voice changing a little (hopefully deeper), but losing my Ls? Good lord!

I was not to eat or drink starting midnight the night before my surgery, so I didn’t. Normally the sleep deprivation has acted as an appetite suppressant, so that and the exercise has caused me to lose 43 pounds in the last 6 months. Missing a few coupla meals hasn’t been an issue, but by 3pm the next morning, sitting on the hospital bed in a hospital gown, my ass hanging out while every nurse and doctor in the place asked me if I’d avoided food and water of any kind and I started to get damn hungry, hoping for the surgery just to have something else to do (although Melissa let me win a few hands of gin, which was nice).

Then the nice anesthesiologist came and slipped me a little something. I felt completely normal for about 10 minutes and then I woke up in the recovery room, the nurses asking me if I could help them move from the gurney to the bed. Seriously. That was my entire surgical experience. Melissa was there, making sure my stuff came with me and asking if I was OK.

Oh, and I was feeling no pain. I don’t remember much from those first few hours. I could talk, which apparently was very unusual. I could walk. I remember my sister-in-law bringing my boys by for a visit and them waking me up every five minutes so I didn’t spill my juice all over myself. I remember several pretty nurses waking me up every hour or so to adjust this sensor or give me that medication. I don’t remember what I said to them, but I do remember making them laugh, which made the increasing pain of my throat more bearable.

We figured out my pain dosage that first night, 10mg of OxyContin every 4 hours mixed with intravenous morphine to take the edge off. I was disappointed that I didn’t get any kind of “high,” though. I just felt fuzzy headed and sleepy. Is that what Rush liked? I don’t get it. I tell you though that the tennis elbow I’d given myself with the free weights in my garage was *completely* cured.

In that first 12 hours, it was my job to be able to walk, go to the bathroom on my own and manage my own pain via oral medications. And I did so. In fact, I was recovering so quickly, the doctor came by and gave me permission to go home hours early. I’d told him the night before that, if my voice had to change, could he push it toward Barry White? Oh, and I’d like to be able to say all my letters if possible. That morning, he asked, “Have you tried it? Can you still say your Ls?”

And then, because I couldn’t not, I channeled A Christmas Story for demonstration purposes: “Fa ra ra ra ra ra ra ra ra!” willing to endure the pain in my throat for the cheap laugh. And I got it. : )

I came home a week ago Friday and have been largely ignoring my work, sleeping most of the time, getting up mainly for drugs every four hours and a little food (Top Ramen, Popsicles and water). The combo put me to sleep within an hour, giving me just time enough to send the random pathetic email or IM before collapsing again. Gradually I’ve been cutting back on pain meds and eating more, my throat just a minor annoyance at this point. It still hurts and my voice is still scratchy, but a quick chug of OC and I’m back in the game, mostly awake during the day and asleep at night.

I went in for my week check-in with the ENT guy yesterday. He was delighted to tell me about micro-pustules and puss inflammation that had riddled my tonsils. Not only where they “huge,” but apparently my body’s been fighting them off as a low level infection for who knows how long. While telling me this, the doctor put a bib around me and handed me a tray to hold as I looked at him questioningly.

“Oh, I don’t think you’re going to throw up,” he said, rummaging for some instruments in a drawer. “I just need you to hold the splints when I take them out.”

As part of fixing my deviated septum, Doogie had put splits in my nose so that things would heal open. At the mention of “splint,” I thought of a little stick to hold my nostril open like the pole in the center of a tent. I thought he’d reach in, cut it in two and pull out a couple of tiny toothpicks. Well, he reached in, stretched my nostril to uncomfortable proportions, clipped the thread holding the split in and started pulling.

Have you seen the scene from Total Recall where Arnold reaches up into his nose and pulls out that giant tracking device? Yeah. Think that except the split was longer. The doctor kept pulling and it kept coming out until it fell with a thump into the tray.

“That was in my nose?!”

“Yep. And there’s another one on the other side,” he said, reaching for the other side.

“There is?!”

“Yeah. Didn’t I tell you? Oh, I guess you were asleep when I put them in,” he said, pulling another canoe out of my other nostril.

“Oh my god!” I said, looking down at the snot covered railroad ties in the tray I was holding.

“Are you OK? You look a little pale. OK, head back…” He was much more comfortable getting the color back into my face the second time, having practiced on me before.

“Nurse! Cold compresses!”

When I was in high school, “game programmer” meant at best BASIC or at worst 6502 assembly language, but either way, lots of text manipulation. These days, high school-age programmers are going to camps and programming competitions having spent their time in drag-n-drop programming environments like Game Maker. They’ve been doing work flow for 7 versions already!

Yesterday, I was a judge and the keynote speaker at a high school game programming contest. After asking a bunch of the 25 teams questions about their games, I was asked to speak about careers in software to 100 high school computer geeks. My people!

Recently, I went to lunch with some friends of mine from the DevelopMentor Software days (wow, *that* was a long time ago) and they accused me of “radio silence” for the last two years.

“What?” I said. “I blog all the time!”

“Oh yeah? What have you been working on again?”

“Uhhh…”

I’ve mentioned my work on this blog in passing as “model-driven” this or “data-driven” that, but never the details. And I still can’t tell you those kinds of details.

But what I can tell you is how I spend my days, because they are *glorious* days.

Have you ever had one of those jobs where you’re energized about coming to work every single day, because whatever you’re doing, it *really* needs doing and it’s going to be different than yesterday?

You might be pushing to finish writing a talk for an upcoming SDR (Software Design Review) or getting that last bit of code checked in before a big internal drop, digging into security threat modeling for the first time or complaining that the thing your team is building is too damn hard to use, only to be told, “fine, then, fix it!”

You could be holding the hand of a new Jr. PM just joining the team or busting the balls of some Sr. Architect that thinks he’s all that and a box of Cracker Jacks, interviewing the next set of folks that are dying to be on your team and turning some away because as much work as you have to do, it’s better to leave it undone than to lower the bar even an inch on the quality standards you’re committed to living up to.

You could be building your own sub-system that we already have 8 of inside the company, but you need some source code you understand and that you can experiment with so that you can add the one or two features you think could really make a difference, only to find out you’ve just built the thing that your management wants to base the next-gen version of that very sub-system on.

You might be meeting your boss in the ProClub locker room when you’re half naked or soaking in the hot tub laughing about some trick you pulled in a meeting, listing the customers that need special attention or cornering an executive in the elevator asking for a really cool thing we have to do for the PDC, damn the cost.

You’re definitely going to be going into work with the smartest, nicest, most fun, more interesting, most sincerely quality-focused people you’ve ever known. After Don had first come to Microsoft for a while, he told me that he’d found his “tribe.” I’d been at DevelopMentor during it’s heyday, so I couldn’t imagine ever finding another group of people I enjoy working with that much. I was wrong. My tribe (of which Don is one of the chiefs) gets so much accomplished because we lean on each other, we trust each other and we spend *so* much time laughing with each other (and *at* each other : ).

Most of you will be able to see the thing I’ve been working on with my tribe at the PDC. Or, if you’d like to help us build it, we’re always looking for new tribe members.

I friend of mine dropped a book with a funny cover in my lap and said, “Hey, check this out.” I threw it on my pile and didn’t get back to it for a few days. When I did, I didn’t know what to make of it. It was like The Grapes of Wrath by Rory Blyth, with illustrations by a drunk Salvador Dali.

It took a few pages, but I eventually figured out that “Shoes” was a cross-platform GUI framework for Ruby and this 52-page book was a tutorial for it. By page 15, I knew the major concepts. By page 20, I could write my first program. By the end, 30 minutes after I’d started reading, I knew the whole thing.

But it was page 24 that completely blew me away. The use of pictures of dominoes and matches to illustrate layout in stacks and flows was genius. This wasn’t just a random collection of wacky illustrations and  non-traditional font choices — the author of this book really knew how to tell a story.

It wasn’t that I wanted to program Shoes, so went looking for a tutorial. It was the tutorial that made me want to program Shoes. Now *that’s* writing.

P.S. This book is not from a publisher — it’s self-published through LuLu.com for cost. There is no bar code, copyright page, Table of Contents or index. It’s just the stuff you actually need to get started programming a completely new thing. And, if you don’t want to shell out the $8.72 to read a paper copy, you can read the HTML and PDF versions instead.

*blush*

Wahoo! You love us, you really love us! : )

When a book goes to another printing, 100% of the time, there’s a list of “errata” (aka “mistakes”) that are fixed in the new printing. In this case, neither Ian nor I have any fixes to apply. So, it’s official — the book is perfect! : )

Thanks for reading.

My 1997 master’s thesis came online today (he says, trying not to flinch). Here’s the abstract:

Microsoft’s Component Object Model (COM) is the dominant object model for the Microsoft Windows family of operating systems. COM encourages each object to support several views of itself, i.e. interfaces. Each interface represents a collection of logically related functions. A COM object is not allowed to expose multiple interfaces using multiple inheritance, however, as some languages do not support it and those that do are not guaranteed to do so in a binary-compatible way. Instead, an object exposes interfaces via a function called QueryInterface(). An object implements QueryInterface() to allow a client to ask what other interfaces the object supports at run-time.

This run-time type discovery scheme has three important characteristics. One, it allows an object to add additional functionality at a later date without disturbing functionality expected by an existing client. Two, it provides for language-independent polymorphism. Any object that supports a required interface can be used in a context that expects that interface. Three, it provides an opportunity for the client to degrade gracefully should an object not support requested functionality. For example, the client may request an alternate interface, ask for guidance from the user or simply continue without the requested functionality.

COM attempts to provide its services in as efficient a means as possible. For example, when an object server shares the same address space as its client, the client calls the functions of the object directly with no third-party intervention and no more overhead than calling a virtual function in C+ +. However, when using COM with some programming languages, this efficiency has a price: language integration. COM does not integrate well with a close-to-the-metal language like C+ +. In many ways COM was designed to look and act just like C + + , but C + + provides its own model of polymorphism, object lifetime control, object identity and type discovery. Of course: since C+ + is not language-independent or location transparent. it was designed differently. Because of these contrasting design goals, a C+ + programmer using COM often has a hard time reconciling the differences between the two object models.

To bridge the two object models, I have developed an abstraction for this purpose that I call a faux-object class. In this thesis, I illustrate the use of a specific instance of the faux-object idiom to provide an object model bridge for COM that more closely integrates with C+ +. By bundling several required interfaces together on the client side, a faux-object class provides the union of the operations of those interfaces, just as if we were allowed to use multiple inheritance in COM. By managing the lifetime of the COM object in the faux-object’s constructor and destructor, it maps the lifetime control scheme of C+ + onto COM. And by using C+ + inline functions, a faux-object can provide most of these advantages with little or no additional run-time or memory overhead.

COM provides a standard Interface Definition Language (IDL) to unambiguously describe COM interfaces. Because IDL is such a rich description language, and because faux-object classes are well defined, I was able to build a tool to automate the generation of faux-object classes for the purpose of bridging the object models of COM and C+ +. This tool was used to generate several faux-object classes to test the usefulness of the faux-object idiom.

Enjoy.

OK, just after all my friends are on FaceBook, now I’m getting the requests to join Spock.com. I don’t know what Spock.com is, but after the address-book thingie, MySpace, the high school alumni thingie, Friendster (?), the Google ork-something, the business thingie and most recently FaceBook, I’m all done. All I ever do on these sites is approve friends requests! Isn’t there supposed to be some value to it other than that?

Oh, sure, I’ve had a few messages from people I haven’t heard from in a while, but email works for that. In fact, email works for a helluva lot of the internet apps I see today. Plus, most of them just forward web form results to my email anyway! Why do I need a whole other thing when I’ve already got all my friends listed in my address book?

I declare the social network backlash officially started!

From now on, I’m going to be doing some anti-social networking around the ol’ Casa de’ Sells. If you want me, you know my email addresses, how to post comments on my blog and my phone number. That should be enough.

“*cough* When I was a boy, we didn’t have these fancy social networks. *cough* *cough* We had email and we were happy to have it!”

“Yes, Grandpa. Shhhh….”

In the same way that .NET manages memory for you, Windows Home Server manages storage. All you have to do is tell it the names of shared folders you want it to have and which computers to back up and it will spread it and duplicate it across however many HDDs you have, without you worrying about which actual HDD your “Music” folder is on or where your wife’s computer is being backed up to.

Plus, if you have more than one HDD and you have “Enable Folder Duplication” enabled for a shared folder, the data in that folder will be shared across multiple HDDs, effectively giving you the benefits of RAID without the config muss and fuss. (It’s my understanding that this cross-HDD data duplication happens automatically for backed up data, but I don’t know how to confirm that empirically without risking the data.  : )

Because a 750GB SATA HDD was $156 at newegg.com, it was a no-brainer to pick one up. It arrived today and it was mean-time of 10 minutes between tearing the tape off the box and the new HDD being used for data storage on my WHS. I didn’t even have to turn off the HP MediaServer machine!

All I did was pull an empty drawer forward, place the new HDD into it and push the drawer closed. Seating the drawer also seated both the data and power connections on the HDD itself, no wires or plastic connectors needed. I want all HDDs to work this way!

10 seconds later, the little light went on that said my new HDD was ready to be added as storage to my WHS, which only took right-clicking in the WHS console (already updated to display the new HDD) and adding it as storage. Another 10 seconds and some additional settings changes to enable folder duplication on my shared folders and the new HDD is in active service, providing redundant storage for all the data I care about in the house.

Really, the only problem I have now is that I only have enough data to fill 14% of the 1.4TB of new storage space. Maybe we need a Windows Friends & Family Server and I could rent out the extra space? : )

Not all was gloom and blackness this XMas. Among the new things in our lives, several of them rocked*:

• Our new HP MediaServer running Windows Home Server is awesome. As a Microsoft employee, I got a killer deal on this server appliance, but knowing what I now know, I’d have paid full price — a whopping $550. In fact, I recently sunk another $200 into it for a memory upgrade and a 750GB HD, bringing it up to 1.25TB.
  
  WHS keeps all the computers in my house automatically backed up, keeps shared folders duplicated across multiple HDs which can be added via the slide-out drawers in the front of the unit (no muss, no fuss) and serves it all up over the web securely. Plus, it’s platform for add-ins, so, for example, if I want offsite storage of everything on the WHS box in case of catastrophe, I can get KeepValue for a flat $100 year.

• My youngest’s new Zune 2 is the best MP3 player I’ve ever touched. We got the 4GB version, which is tiny, but still comes with amazing video playback, an FM radio and very intuitive controls. (I know I’m unusual in this regard, but when I first touched the iPod, I had no idea how to make it work and the manual didn’t help.)
  
  The client software is also a joy to use. The look and feel is unique and simple. Both the client and Zune UIs make me hope that those guys actually are building a phone. I want it.
  
  Plus, we got a pair of the Altec-Lansing Zune speaker dock from woot.com for $40 and they sound great, worked instantly and come with the cutest remote control. Very nice package.

• I can’t wait to put my new portable Bosch 10″ Table Saw with Gravity Rise Stand to use (thanks, Babe!). I’ve been remodeling my homes for years, doing as much of it myself as I have time for, but was missing a saw to do straight rips. I’m all set now!

• My brother-in-law got Rock Band for his family and it *rocks*, especially the tone feedback on the microphone. (I love to sing, which you’ll know if you’re ever trapped in a car with me and Bohemian Rhapsody comes on the radio : )

• My youngest also got a pair of the Killer Rabbit Slippers, which Chris picked up for me when he and his wife went to Spamalot. I’d covet my son’s new slippers except I love the Goofy loafer Slippers I stole from him years ago. : )

What did Santa bring you this year? Anything you’d recommend or want to steer folks away from?

*Yes, I know I’m a Microsoft employee and biased. Feel free to take what I say with as much salt as your heart can take. : )

I brought my son a Sidekick Slide cell phone for XMas this year and I’ve come to the conclusion that it sucks, or at least the way T-Mobile sells it sucks.

When I purchased it, the T-Mobile salesman offered me unlimited data and text messages for an additional $20/month on that line. The phone was an upgrade on our existing family plan, which already has 3000 minutes/month and unlimited text messaging and I don’t really need my son surfing the interweb during class, so I declined. He never mentioned that the phone wouldn’t actually work without this extra money, or I never would’ve purchased it.

Then, XMas morning rolls around, my son is super-excited and plugs his SIM card into his new phone, turns it on and is greeted with the activation screen. This lasted for hours. Eventually, he found the magic key combination and was able to use the phone, but when it crashed, it lost all his contacts and pictures. Plus, the battery life sucked, lasting maybe four hours between charges. The boy swears it’s because it’s still trying to activate in the background.

Finally, we called T-Mobile “customer care.” If I wanted to use the “full capabilities” of the phone, like save f-ing contacts, we pay the $20/month. The contacts are saved “on the network” *only*. That sucks. This was a $200 phone subsidized with a 2-year extension to the contract and it can’t store f-ing phone numbers?!?

I was about ready to cram the phone back up the T-Mobile salesman’s…. well, I would’ve returned it, but the boy was so enamored, he committed to ponying up the dough from his allowance.

And I have a sneaking suspicion that even though we now have the “Sidekick feature” package, that the battery life is *still* going to suck… Keep your fingers crossed.

P.S. I can’t tell you how much my son loves this phone…

Yesterday I got an email from a fellow named Corrado Cavalli to whom I sent a free copy of Programming WPF. When he received it and read through it, he posted a note on his web site, which of course, I went to read.

Now, Corrado lives in San Pellegrino Terme, Bergamo Italy, so his blog is in Italian. That didn’t stop me from reading it in English using Google’s language translation page.

Then, just to be “cheeky” as my Australian friends say, I composed simple responses in English and translated them to Italian before posting them, you know, pretending I’m smart and international and such like. : )

To be somewhat confident I wasn’t asking him for improper knowledge of his dog, I did the Italian to English translation on the translated text and rearranged my English it bit when it wasn’t quite right.

All in all, I’d say it worked out pretty well, although I did get some flowers from his dog the other day…

Dvorak asks this about One Laptop Per Child:

“Does anyone but me see the OLPC XO-1 as an insulting ‘let them eat cake’ sort of message to the world’s poor?”

I can see his point, but I don’t see how decades of giving food and support to the 3rd world has helped them to become part of the 1st world. Maybe access to the world’s information so that they can educate themselves and learn how to solve their own problems might work a little better. It’s worth a try at least.

I mention this because this is just the thing I’ve wanted to be able to check my kid’s math homework: the Microsoft Math Add-In for Word 2007.

For example, after installing it, I can open Word, press Alt+= to get myself a new equation and then enter:

x^2 +2x + 2 + 3x - 4x^2

it translates into:

If I right-click and choose Simplify, I get the following:

If I right-click again and choose Plot in 2D, I get:

If I’ve got an equation that I want to solve, I can enter it:

and then right-click and choose Solve for x and get all the possible solutions:

This even works if you have multiple equations with multiple unknowns, which means this is good through at least 8th grade Algebra. Wahoo!

OK, what’s the deal with installing 1 product (Visual Studio 2008 beta 2) and having to do 22 separate uninstalls?!? How is this a good thing?

Normally, this is the kind of question I’d pose and then provide an answer, but this time I just don’t have one.

If my Word settings were stored in %HOMEPATH%\WordSettings.xml, I could edit the file, back it up, carry it to other machines and generally manage it. Instead, my settings seem to be stored in the Registry, %LOCALAPPDATA% or %APPDATA%, but who knows what’s stored where or how to manage it.

Obviously, Unix already does just this and I’m jealous. If I had settings stored somewhere I could understand and apps that actually used XCOPY deployment, I wouldn’t have to uninstall at all — I could just delete.

These are the thoughts you have uninstalling VS05 and VS08b2…

In general, IE7 more than meets my needs. It shows me the web pages I want and it works well. However, there is one killer feature that FireFox has that I desperately needed yesterday that caused me to load it onto my machine. It’s not my default browser and it doesn’t replace IE7, but FireFox is there and fulfilling my one killer feature needs nicely.

What’s the feature, you ask? Well I’ll tell you: sane content scaling. IE7 has Ctrl+, but it works very poorly, unlike FireFox, where it works fabulously.

Here’s the problem. Yesterday, I started reading the most excellent C# 3.0 in a Nutshell online, but the “Text Zoom +” button didn’t increase the font size nearly enough for me to read on my giant LCD monitor. So, I started pressing Ctrl+ on IE7 and the text got bigger, but it didn’t wrap the text inside the window, instead giving me horizontal scroll bar. This confuses me, because IE wraps text just fine when the window is resized or when the text size changes — why can’t it wrap when the content is scaled?

Anyway, FireFox rescales things very nicely and made my online reading very pleasant.

I absolutely love what the Albahari brothers (Joe & Ben) have done with C# 3.0 in a Nutshell. Not only is their prose concise in a way that mine is not, but I have learned a bunch of stuff about LINQ I didn’t know, they built a tool (LINQPad) that lets you experiment with LINQ interactively in a way that the designers of LINQ themselves don’t support and the tool has all kinds of wonderful features that LINQ, SQL and Regular Expression programmers alike will want to use regularly long after they’ve read the book.

And if that weren’t enough, the tool comes with an integrated tree of samples that follow along with the material in the book, teaching the material from another angle and reinforcing it perfectly. It’s pure genius and if I ever write another book, it’s a model I’m going to follow. Very highly recommended.

When I was a kid, Christmas was my favorite holiday because my entire family (grandparents, parents, siblings, cousins, aunts and uncles) would get together at our lake cabin, chop wood for the fireplace by day and play games at night, culminating in an hours-long gift opening bonanza on Christmas Eve where each of us would watch the opener open a gift, youngest-to-oldest, one at a time. Did we like opening? Sure, but even better was seeing the look at the person’s face when you’d managed to get them just the right thing because you saw them all the time and you knew what they wanted.

Now, I’m building my own family in Oregon, but I still have parents and in-laws and grandparents that need Christmas presents. Do I know what they want and need? No, because I hardly ever see them. Do I get to see their faces when they open the gifts? No, because I’m in Oregon. Does that get me off the hook? No, because when the presents don’t show up in time, one or two have been known to call and complain. So, what’s a remote relative to do?

In the past, I’ve floated the idea of sending donations in their names to various charities, but that seems kind of like a cop out, as there’s no real thought or effort in it. Plus, it’s not every much fun to open.

This year, I thought I’d give an hour of volunteer service and then write a little story about it for them to read around the tree in our absence. I’ll pick an organization that fits their personality. For my step-mom, I might walk dogs at the local Humane Society (she likes dogs). For my Grandmother, I might volunteer to drive some elderly shut-in on her holiday errands (as I do for her when I can when I’m in town). Then, step-mom and Grandma can hear about how the hour went and share it with whoever they’re opening presents with by reading my description out loud. This way, someone gets something they need, I’ve put in the effort to show my loved on that they really are loved and there’s a little something under the tree.

Thoughts? Has anyone done something like this before? Does anyone have any ideas for Portland-area organizations that can help me get my volunteer hours in this holiday season?

I truly believe that the future of employment will be much more individualistic and that requiring people to move will be an anachronism. Right now, phone + LiveMeeting is about 50% as good as being there; you’re limited in what jobs you can do based on how much a part of your job “being there” actually is. We already have the pieces of technology to push “being there” to about 80%; we just haven’t put them together yet. When we do, a bunch more barriers are going to come down. Until then, some folks are on the bleeding edge and isn’t that what this whole industry is about anyway? : )

• I used to drive up because it gave me the freedom of traveling whenever I wanted and I always had a car on the far end. Besides the speeding tickets, the other big problem was the amount of human energy it takes to drive back and forth so often.
• I’ve taken the train, which I love because of the comfy surroundings and the electron dispensers, but if I want to be at a 9:45am meeting on Monday morning, I have to leave on the 2pm train on Sunday, which really cuts into family time.
• Now I fly. The drive to the airport is only 30 minutes and I’ve never gotten a ticket along the way. When I get there, I use the express line to Seattle flights and get myself a Chai tea on the far side of security, itself made easy by long practice and my slip-off Crocs. The flight is short and I’ve long ago dropped off luggage that I leave in building 42, so I only have to bring clean undies in my laptop carry-on. When I land, instead of renting a car, I take a cab and get the benefit of the HOV lane when means I can take the 8am flight instead of the 7:30am flight, giving me 30 more minutes in bed. When I arrive, I have a junker freebie car I leave in the parking lot for tooling around town.
• I split my overnights between my long-time friend and mentor Don Box and a local hotel. I stay at the hotel because I don’t want to overstay my welcome and I stay at Don’s because he and his family have made me feel so at home that I can’t not stay there. As much as Don would prefer I be in WA, he has really gone a long way to enable my lifestyle and I love him for it.
• Sometimes when I’m on a roll, I’ll keep going long into the night, just like the old days at DM. And sometimes when I’m not feeling it, I’ll take the afternoon off and see a movie with my sweetie. It’s all about the balance.
• I’ve always had an office for when I’m in Redmond, but I’ve always made sure I was the first guy on the double-up list when things get tight. Now only does this give me more face time when I’m in town, but I look like a hero and the guy who rooms with me only has to put up with me 3 days out of 10. I also let the other guy decide how to lay out the office, since my real office is set up just how I like it at my house. I’ve worked on couches, in the hall, in conference rooms, in the care and at the local Starbucks on 156th. Give me a laptop and wi-fi and I’m good to go.
• Keep a machine setup inside the firewall. Every once in a while, VPN won’t let you do anything except terminal serve into a machine, at which point you can do anything just like you were there.
• Make Microsoft pay at least half of your phone and internet bills.
• Just because you’re working from home, you should expect adequate equipment to be supplied by your employer. Over a 4.5 year period, Microsoft has supplied me with two laptops, a 20″ LCD monitor and a printer-fax-scanner-copier, all in my home office.

Tomorrow, I’ll post the final entry in this series with my thoughts about the future of telecommuting.

When I went to work for Microsoft without moving up, I knew I was making a tradeoff. Before Microsoft, I spent a lot of time traveling, so MS meant staying home much more with my family. It also meant, because of MS’s cultural bias, that my rate of advancement would be considerably slower than it would be if I was local. In fact, I was prepared to be completely unpromoted as several senior folks I trusted at Microsoft promised I would be. As it turned out, even though I came into Microsoft at a fairly high level (high enough that it wouldn’t have been hard to not meet expectations even if I were local), I was promoted. I doubt seriously that I’ll be promoted again, but I never thought I would be promoted at all. In fact, I’ve often referred to my Microsoft job, especially my new one on a product team, as “the world’s greatest dead-end job.” : )

I know this sounds bad, but it gives me two freedoms. First, and most importantly, it gives me the freedom to spend evenings and weekends with my family (especially since I shipped the last book I plan on working on for a long, long time) and to put them first. This was the conscious decision I made going it and I’m happy every day that I made it. The second freedom that took me by surprise is that I can focus on the parts of my job that I really love without worrying about picking up tasks just because they’ll look good at review time. It’s almost like I’m one of those Microsofties with “fuck you money” without the actual money. : )

Because my current boss cares deeply about making me as successful as I can be, we’ve talked about me having direct reports. I’ve done it before and I believe I could do it effectively again, even remotely (I’ve run successful remote development teams all over the world). However, because of the strong MS bias, I told my boss that I’d only take direct reports that had bought into the downsides of being remote, even if they’re local. If I’m not perceived as effective because I’m remote, then by extension, neither will anyone that works for me. My boss hasn’t pushed it since our conversation on that matter and frankly, I don’t expect to get any reports, but he’s surprised me before, so we’ll see. : )

Tomorrow: Misc tips & tricks.

Communicating during a meeting is an art unto itself and has its own set of considerations:

• Learn to love LiveMeeting: If you can’t see faces, the next best thing is whiteboards and what’s on each other’s computer screens. For whiteboards, you really need a video camera, which I’ll talk about later. For desktop sharing, I’ve tried NetMeeting, VNC, Terminal Services (in shadow mode) every version of MS Messenger, Office Communicator, Vista Meeting Space and LiveMeeting and a bunch more I’m not remembering. The only one that works consistently through firewalls (mine and Microsoft’s) and is easy to get bootstrapped is LiveMeeting. Learn how to start a “Meet Now” meeting (I have an URL that starts up the “Meet Now: Chris Sells” meeting but I have no idea where I got it) and use it! I’ve actually heard Don Box, who hates working with me when I’m not in the room, say “LiveMeeting is better than you being here!” And when you’re jointly working on a shared document or shared code, it’s pretty damn good.
• Get a LiveMeeting monkey: If you’re going to do a remote presentation, make sure there’s someone on the other end with LiveMeeting tested and running that can project your slides for you while you narrate.
• Learn the short path through LiveMeeting: Microsoft employees, like most humans, don’t like to be distracted by things they don’t care about. They don’t want to install a new piece of software on a machine they just got working again last week and they certainly don’t know how to use it. Make sure you can talk them through the shortest path to getting LiveMeeting installed and sharing their desktops. The first time, this takes 10-15 minutes of disk churn (unfortunately), so ideally you’ll do it before the big meeting.
• Keep time zones in mind: Martin was at GMT+0. Tim was at GMT-5. Microsoft is at GMT-8, as am I. Being working and available for meetings, phone calls and quick turn emails is important, otherwise, your team is going to start forgetting to include you in ad hoc stuff, as was a problem for Tim and completely impossible for Martin.
• Meet new people face-to-face: I go up to Microsoft 3 days/2 nights every other week with the idea that I’m not going to get much actual coding or writing done, but I’m going to get face time with new people I need to start relationships with. When they hear you’re remote, most folks at Microsoft will want to postpone the meeting ’til you’re in town. To make them comfortable with you and to put faces to the voices, that’s a good idea the first time. However, after that, phone calls are just fine, especially when combined with LiveMeeting.
• Learn your address book: When a meeting room is scheduled, the scheduler doesn’t know the phone number for the meeting nor are they even going to remember that you’re calling in, so you need to know how to get the phone number yourself. At Microsoft, the address book lists conference room phone numbers as “conf room [blg]/[room],” e.g. “conf room 42/5646″. If you have any trouble or you need someone to call you a cab for the airport on the last day of your trip, you can look up the receptionist for the building you’re in with “Reception Bldg [bldg],” e.g. “Reception Building 42″.
• Get your own personal conference call number: If more than one person is calling into a single meeting room, have your personal conference call phone number and code ready. Again, Microsoft issues these to anyone that wants one (and again I can’t remember where I got mine : ).
• Take meeting notes: If you are finding yourself missing out what’s going on during meetings while you’re on the phone, offer to take the meeting notes. That way, when you have questions, you’re asking as the guy taking notes not the annoying guy who’s too full of him/herself to move.
• Play solitaire: If you’re not taking notes and you find yourself zoning out during a phone meeting, either because you’re surfing the web or starting to do “real” work, you need to do something that will occupy your eyes and your hands while keeping your ears and brain free to pay attention. For that I recommend solitaire or, when I’ve really let my work interfere with my home life balance, I like to put the dishes away or fold clothes. Handy access to the Mute button on your phone covers up the “clink” noises. : )
• Learn to intuit what’s going on to the whiteboard: I find that the single biggest downside to not being there in person, especially on a product team, is not being able to see the whiteboard. Microsoft has a face-to-face, brute force culture; if a design or implementation problem can’t be solved in two sentences in email, that’s cause for a whiteboard scribble session. What I’ve learned, however, is that most such whiteboard scribbles look the same: there are going to be some boxes, some lines and some letters. The most powerful thing about what’s happening on the whiteboard is not the whiteboard itself, but the story that’s told while the boxes and lines are being scribbled. With some practice, you can learn to guess what’s on the whiteboard by listening to the story, even if you have to ask a clarifying question or two. Further, just the mere act of saying something like “Well, I’m just guessing, but what I think you think drew is…” More often than not, the folks on the other end of the phone will say something like, “Wow. That’s pretty close, Chris, except that…” With a little practice, you too can become a “whiteboard whisper.” : )

That’s not to say that I wouldn’t love a better solution for remote telepresence then I’ve got. I’ve tried a number of experiments over the years and right now Scott Hanselman and I are trying yet another one. For me, a basket of laptop that my team can carry to meetings for me that’s running Skype for a/v sharing (it works through firewalls and does great noise cancelation), with a high quality pan/tilt/zoom camera I can control from my end is the killer app for remote employees. Scott’s got more of a mobile IvanAnywhere mindset, but between the two of us, we hope to cobble together something that closes 80% of the remaining gap I can’t close with the communication tips I’ve listed above.

Tomorrow we’ll discuss the career consequences of working remotely at Microsoft.

Assuming you can focus on work and you can find someone to hire you, effective communication is the next issue you’ll run into. When I was working for DM, practically everyone was remote, so our communication was based on email conversations that would be long and involved, sometimes lasting for days. However, that’s not the case at Microsoft, where brevity in email is valued and meetings are called for the tough issues. How do you fit into this culture? I use several techniques:

• Over-communicate: I like to check and double check the things I heard and read vs. the things I’ve seeing done. “I did X. Can you check it and make sure it’s what we agreed on?” “We agree that you were going to do Y. How’s that coming? I looked at that last check-in you made and you seem to be doing Z. Why?”
• Pick good email subjects: Lots of times, people have so much email, if the subject isn’t relevant, they don’t bother.
• Keep emails short: At Microsoft, we have literally thousands of mailing lists and it’s not unusual for a single employee to belong to tens of them, generating 200-500 emails/day. If you want to be heard in that ruckus, you have to be succinct. If you get a reputation for long, rambling emails, especially without a summary, your missives will be ignored.
• Summarize long emails at the top: When I need my email to go over a page, I summarize it at the top with a single sentence or two. That saves folks from having to dig through an email to get the gist.
• Resend emails: I know Raymond Chen says not to, but if you don’t get an answer to an email, send it again. I can’t tell you how many times the first email was ignored, but the second email was answered.
• Reply to yourself: If you’re asking a question that doesn’t get answered, follow up with the answer when you get it. I’ve had threads of conversation that were 80% me. At least they’ll see you’re there so they’ll remember to keep sending the paycheck. : )
• Follow up on hints: Sometimes you’ll see something go by in an email that implies a different understanding than you had when last you talked to folks. For example, you’re expecting to participate in a design review on Wednesday, but someone sends an email including the sentence like, “We’ll have to have this question answered by Tuesday’s design review anyway.” In the hallway/meeting/face-to-face communication culture of Microsoft, decisions are made and changed all the time without a written follow-up, but most of the time you’ll see the new data referenced in some kind of way. When that happens, follow up, e.g. “I thought the design review was on Wednesday. Has it been changed?”
• Read those status mails: You’re saving all kinds of time and being more productive by skipping those random conversations in the hallway, so you can afford to actual read your colleagues’ status emails. I also like to follow up on them, asking questions about the stuff I’m curious about. Often it helps me get my own work done and it almost always means I can integrate my work with that of my team’s better.
• Own the efforts you’re involved in: It’s very easy to get focused on your own work and get out of sync with the team. If you’re dependent on other folks to get their work done so that the thing you’re doing gets done correctly and on time, you’ve got yourself a powerful motivator to communicate.
• Get everyone on your team to use IM: IM is a wonderful simulation for hallway conversations that works even when the target of your question/comment is in a meeting (it’s common for Microsofties to have their laptops open during meetings). At Microsoft, even if folks don’t have a personal IM account via Yahoo or Live Messenger, they do have one with Office Communicator. If you’re trying to get someone that’s never online with it, instead of sending them an email with your question, send them a link to the Office Communicator installation and a request for them to log in. If that doesn’t work, start calling them and asking them the same thing. They’ll get the hint. : )
• Pick up the phone: A ringing desktop phone is a novelty at Microsoft that few folks will ignore. Use it to startle them into submission! : )
• Schedule a meeting for a phone call: If you can’t get your team on the phone for a quick discussion, schedule a 15-minute phone call.

Tomorrow I’ll focus on remote communication during meetings.

Assuming you decide you can and want to work from home for Microsoft, now the trick is finding someone that will take you. The first time, this took me years. As my writing and speaking became more popular, I’d get more regular calls from someone at Microsoft with “the perfect job for me.” Each time, I’d ask them if I had to move and when they replied, “Of course” as if the entire pool of worthy workers lived in Washington, I’d politely decline. Eventually when the question came up, Sara Williams said, “No need to move” and I went to work for MSDN. As is often the case with one’s first Microsoft job, it wasn’t a long-term fit (a software engineer needs to be on a product team!), but finding a product team took me took 6 months of digging. All the groups I talked to wanted me and they all were happy to move me (some even offered to move my extended family up, too, eliminating my main anchor for staying in OR), but culturally they just didn’t know what to do with a remote guy.

Eventually, persistence, and my long experience working remotely, paid off and I actually had two competing offers (and I’m *so* happy about the one I chose). Microsoft has a *ton* of open positions and they get more open about remote employees all the time. Keep at it!

Tomorrow: Can You Communicate Effectively From Home?

First off, I don’t recommend remote work for folks who don’t like spending the vast majority of their time away from their colleagues, sometimes having trouble focusing on the work in favor of household duties or interactions. In fact, the ability to focus on work while at home is the #1 issue you’ll have to face as a remote employee and I’ve seen it drive 80% of folks back to the office. I’ve always been naturally in the 20% bucket on that issue.

As an example, when I first started at DevelopMentor, my office was in an open back room separated from the dining room by a hallway kitchen. My two infant boys had me in clear view when I was handcrafting RPC packets for communication with a DCOM server, hanging on the child gate, crying for me to play with them. My wife also had in plain sight when she wanted something from the high shelf. My family often heard me protest, “You know, I am actually working over here!” I eventually built a door, purchased Melissa a stool and learned to be very mushy about the split between work and home life. My family’s actually been very supportive and I’ve always preferred the work environment I’ve established at home over any I’ve ever had from an employer, if for no other reason than my home has my family in it.

My advice to anyone that wants to switch to remote work is to try it for a month or two first. Are you able to balance work and family life when you’re at home? Are you able to go for days or weeks without the hallway conversations with your colleagues? Can you communicate effectively in ways that aren’t face-to-face? If you don’t like it, don’t force yourself into it. For example, while DM instructors didn’t seem to have any attrition due to remote work, all of the names I listed above as remote Microsoft employees have either quit, moved to Redmond or complained bitterly during their transition (Scott’s still new : ).

Tomorrow I’ll discuss “Can I Find Someone To Let Me Work From Home?”

I’ve been at Microsoft about 4.5 years, the whole time a “remote employee,” i.e. I work mainly from my home in a suburb of Portland, OR but the teams I’ve worked for have all been based at Microsoft HQ in Redmond, WA.

Microsoft is traditionally a company that moves the bulk of their employees to WA, especially for product team and related duties. Of course, we’ve got subsidiaries and sales world-wide, as well as the occasional technology team in talent hot spots around the world, but there is a large corporate bias towards moving new hires to HQ. In fact, so much so that when we’ve got open spots, I’ve learned not to recommend someone that I know won’t move.

And yet, there are notable exceptions. Martin Gudgin worked from England for a number of years. Tim Ewald worked from New Hampshire. Scott Hanselman works from Portland, as did Rory Blythe. Sometimes if there’s enough need and the right role, the distance bias can be overcome. And when it does, I sometimes get an IM, an email, a phone call or a meeting request so that I can answer the question: how do you do it?

Tune in tomorrow for “Can You Focus On Work At Home?”

John Osborn of O’Reilly and Associates had this to say in my morning email:

“Congratulations, guys. The book is printed and shipping! Just got my copy this morning and it looks great. A very substantial body of work, to say the least.

“Thanks for all of your hard work on this project. Now to crank up the PR machine and make sure no book shelf is without a copy.”

Wahoo!

I wanted to figure out how to emit a new CLR type at run-time using Reflection.Emit and Google revealed the following article: Generating Code at Run Time With Reflection.Emit in DDJ.As usual, I skip most of the initial prose to the first code sample (I don’t need some author’s fancy intro — I just want the code!). Then, I’m reading along and I find some phrases I enjoy, e.g.

“If you plan on generating lots of calls to Console.WriteLine(), you should be aware that the ILGenerator class exposes a method for just that purpose: ILGenerator.EmitWriteLine() generates the exact same code as our example. (Could this be the first assembler ever devised that includes explicit support for creating “Hello, World” sample programs?)”

and

“When creating a dynamic assembly with Reflection.Emit, you must declare, ahead of time, what you plan on doing with it. Do you want to run it or save it? Or both? (Of course, if your answer is ‘neither,’ then you should probably should have stopped reading this article long ago.)”

By the end of the piece, I’ve enjoyed the story and it told me exactly what I wanted and then some, pointing out some pitfalls I would’ve missed, being entertaining along the way. It’s rare that I enjoy an article so much and I’m thinking I should send the author an email, congratulating him/her on his/her tight, fun prose.

And then I get to the author bios:

″Chris Sells is a blah blah blah.”

″Shawn Van Ness is a blah blah blah.”

Of course, now I remember Shawn writing this piece and me helping him with the polish. At this point, I feel a bit like the Joey Tribbiani of Windows technical writing…

Buy your copy today! : )

P.S. I read the QC1 (Quality Check 1), all 859 pages of it, in two solid days this weekend. I found a bunch of nits, all of which will be fixed before you see it in August. Wahoo!

I was really loving my T-Mobile Wing with WM6, Pocket Office, external micro-SD slot, slamming keyboard, beautiful ClearType display, one-handed usage (even though it is a PocketPC, I almost never needed to pull out the stylus), blue tooth (very high quality!), wi-fi, Edge and a slamming keyboard! (yes — it was that slamming.).

Unfortunately, I couldn’t keep it. After four days of the battery going dead after 12 short hours of my normal usage, e.g. email, texting, surfing, etc, it was dead. I turned off wi-fi, blue tooth and DirectPush to no avail. The T-Mobile Wing is just too cool for the battery and T-Mobile didn’t have a bigger one to give me.

So it’s back to my i-mate smartflip (hurray for data sync!). I was *so* loving that slamming keyboard…

Here’s another one:

For example, if we had had a background in journalism, we might have used one-based indexing instead of zero-based indexing to…

That Ian didn’t like, but it still makes me smile (and if you’re not a smiling author, why be an author at all?!?).

I forgot until the copy edit review process that I’d dropped this gem into a footnote:

On August 4th, 1997, the world’s oldest person so far, Jeanne Louise Calment, died at age 122, having taken up fencing at age 85 and out-lived the holder of her reverse-mortgage. Although I firmly believe that Ms. Calment is showing us the way to a richer, longer life, it’ll be a while yet before we need the full range supported by the Int32 class (2,147,483,647 years young).

This is what happens when you write into the wee hours of the morning… : )

I submitted the final manuscript for Programming WPF, 2nd edition, by Ian Griffiths and Chris Sells to O’Reilly and Associates this morning for publication. Of course, there’s stuff still to do (today we hit step 8 of 18), but this represents a major milestone in the life of any book.

I have mixed feelings when I finish a book. The last few have been especially intense, as I have a real day job on a Microsoft product-team-to-be, so it’s just been evenings and weekends. With this much work to do, you have to focus hard and the work becomes a part of you. This means that giving it up is also hard. My boys are just now becoming teenagers, so it’ll be a while yet before they leave home, but I imagine I’ll feel the same kind of melancholy I feel now — happy to see something you’ve put so much of your life into make its own way into the world, but hard to have the cord cut.

On average, I’ve been an author, co-author or a “with” on 12 books over the last 12 years. At one time, I had open contracts on four separate books. This book represents my last planned book. I’m now truly an empty nester.

So, what’s next for me in this new phase of my life? Well, I’ve already started some stuff. A couple of weeks ago, I started a little gooey shell for monad (I call it “gonad”  : ). And last Friday, I started private piano lessons (a blast!). I’d like to pick up my other hobbies again, too, but for the life of me, I can’t remember what my other hobbies used to be…

This was an email I sent to Glyn Griffiths, the final external reviewer on the WPF 2ed book before we submitted the final manuscript for copy edit and publication (and which has been posted here with his permission):

Mr. Griffiths, in chapter 7, you had a couple of comments about what happened in the 1ed of the book vs. what we’ve got now in the 2ed of the book. The first such comment was:

“The first edition of the book had ‘…selected by going backward and forward…’ which I think is better. [ed: as compared to ‘selected back and forward’]

“This is one of several instances I’ve found of improved wording in the first edition that seems to have been lost in this one. Is this because work on the second edition was started using a text base that was earlier than the final version of the first edition?”

To answer your question, the post-copy-edited version of the 1ed is in Framemaker. Apparently, ORA does have a process for getting Word documents out of Framemaker for just this reason, but I didn’t know that, so we started with our pre-copy-edited 1ed Word documents when we started the 2ed. Since so much of the 2ed prose is different than the 1ed, this doesn’t concern me overmuch, but it’s worth avoiding for the 3ed.

And now here’s my question: how the hell do you know what was in the 1ed at this level of detail? Have you memorized it so that you can do a diff in your head? Do you have it open in front of you so you can compare? I can’t imagine what powers you possess to be able to make comment such as these, but I’m happy to have you use them for good and not evil.

P.S. With your kind permission, I’d like to post your comment on my blog so that others may have a greater understanding of where Ian gets his monster intellect.

Now that Chris Anderson’s most excellent Essential Windows Presentation Foundation has transitioned to the physical world, I thought I’d share my foreword:

Thank God there weren’t more people like Chris Anderson when I was making my living outside of Microsoft.

I work at Microsoft now (two doors down from Chris, in fact), but not all that long ago, I was an instructor at a Windows developer training company. My brethren and I were led by a deep-thinking PhD candidate that applied the same rigor he applied to a scholarly pursuit that had to stand up to the “crush or be crushed” mentality of academia. We learned how to think clearly as a defense mechanism and to communicate clearly as a survival technique. If we didn’t do it to his exacting standards, he’d sweep us aside and redo our work before our eyes (we learned to call it “swooping” and you worked hard to avoid the phenomenon).

In a similar fashion, we learned to ignore the tutorial and reference materials produced by our vendor of choice, because it was clear that however clearly they may or may not be thinking inside their hallowed walls, it was certain that they weren’t up to communicating it with the rest of us. Arguably, our whole job for close to a decade was “swooping” Microsoft itself, redoing their materials in the form of short course, conference talks, magazine articles and books. We called it the “Microsoft Continuing Employment Act,” treating it like a pork barrel entitlement program that kept us in the style to which we had grown accustomed.

In fact, we made a nice living traveling the country saying things like, “remember to call Release,” “avoid round-trips” and “ignore aggregation” because these were clear guidelines that distilled for developers what Microsoft couldn’t manage to say for itself. That’s not to say that there weren’t clear thinkers inside of Microsoft (Tony Williams and Crispin Goswell being two of my very favorites), but the gap between the beginner and the reader of such advanced writings was largely unfilled in those days.

With this book, that gravy train has run right off the track. Chris Anderson was one of the chief architects of the next-generation GUI stack, the Windows Presentation Framework, which is the subject of the book you’re now holding in your hands. You’d have thought that the very nature of the architecture job, that is, to make sure that the issues deep, deep inside were solved properly so that others could come along and build the trappings that made it into plain sight, would disqualify him from leading the developer from “go” to “whoa,” but that’s not the case. Chris’s insight allow him to shine a light from the internals of WPF to those standing at the entrance, guiding you through the concepts that form the foundation of his creation (and the creation of more than 300 other people, too, let’s not forget).

As the author of a competing book from another publisher, I can’t say that this is the only book you’ll ever need on WPF (or they’d have me in front of a firing squad), but I can say this with certainty: it belongs on your shelf within an easy reach. I know that’s where my copy will be.

I’d like to provide a list of the best WPF resources, including real-world apps, free web resources, SDK docs, samples, blogs, etc. If you’ve got something that belongs on that list, I’d love to hear about it. Thanks!

Jimmy, a very polite 14-year old student of Washington Manor Middle School in California had an assignment to interview a computer programmer. I have no idea how he found me, but I did my best to help him out.

[jimmy] Thanks for your time! Here are the questions…

[jimmy] How long have you been working in this profession?
[csells] I’ve been a professional programmer of one kind or another since I was 20 years old, so 17 years.

So, I’m sitting in my office pair programming with Geoff Kizer when my phone rings. It says “Microsoft” on the display, so I figure it’s one of my brethren.

“Hello?”

An angry voice replies, “I’m calling you because your technical support sucks and I’m tired of being put on hold!”

“I’m sorry? Are you a Microsoft employee?”

“No! I’m a *customer*! I’m trying to use Windows Vista Ultimate 64-bit and it doesn’t work!”

“Oh.” Now I’m reaching way, way back into my distant technical phone support past. First, defuse the anger by empathizing with the customer. “Well, on behalf of the 70,000 Microsoft employees, I’d like to apologize.” That was a little over the top — have to dial it down a bit next time…

Second, try to take things back a step and establish a rapport with the customer. “My name is Chris. What’s yours?”

Calming down a bit, “John.”

“OK, John. I can’t claim to know everything there is to know about Vista, but I’ll answer your questions if I can.”

“How do I get the icons to be smaller on the desktop? No matter what the resolution is, they’re always huge! I want them to be small like on XP!”

“Are you at your computer now?”

“Yes.”

“OK. I know you can change the icon size on the desktop. Let you look around a little.” At this point, I’m opening up the Personalize control panel, finding nothing about desktop icon size. I used the cool narrow-as-you-type Help. Nothing about icon size (although I can change the icons themselves). Now I’m cursing Vista myself. “I don’t see it here,” I admit to John.

At this point, I look up and notice I’ve gathered a crowd outside my office, including my boss and his boss, all laughing because a) dealing with angry customers is not the most fun job in the world and b) they’re glad it isn’t them.

At this point, Mr. Kizer reaches over to my computer, right-clicks on my desktop and shows me the context menu option that actually changes the icon size, which I share with John, making sure he’s happy with this solution before moving on.

And move on we did. John has one more problem, which I repeat back to him to make sure I’ve gotten it right, emphasize with him and try to help him reproduce it. When we can’t, I send him an email, asking for some additional data when he is able to reproduce the problem so that I can follow up with a fix, apologizing again for the trouble he’s had today, both with Vista and with tech support.

After about 15 minutes, John thanked me and asked me if I was in Sales or Support.

“No. I’m a developer,” which was close enough to true for your average person.

He then told me how he got to my phone in the first place. Apparently, he had called the main number and was tired of being put on hold by our support, so he told our voice-recognition system that he wanted to speak to “Sales,” I’m guessing to give them a piece of his mind. That day, “Sells” was enough of a match to “Sales” and suddenly, I’m the one talking to John.

At no point during this call did I consider sending John somewhere else for help. He’d already been through our support and didn’t like it. I can’t make people purchase Microsoft products. I can’t make people like Microsoft products. However, that one day with that one customer, I was going to do my best to help one customer to not hate Microsoft. Sometimes that’s all you can do and I was proud to do it.

I’ve been having another adventure in social video conferencing, this time with my team in Redmond. It all started with Doug brought his 360 into our new conference room, which is just an office with a coupla white boards, some comfy chairs and a 37″ LCD panel for projecting.

Once we got the 360, I purchased a year Live Gold subscription and a live camera for $30, turning it into a video conferencing solution. Now, every morning at scrum, I’m sitting in my living room, telling folks in building 42 what I did yesterday, what I’m doing today and whether I’m blocked or not and they can see as well as hear me. When we go around the room, somebody turns the camera for me and it’s my turn when we get to the LCD panel.

You might ask why we don’t just use Live Messenger’s video support and the answer is — configuration and hardware. Live Messenger’s video just never seems to work out of the box w/ people’s s/w and h/w firewalls and even if it did, nobody’s got a camera on their laptop. Now, the only thing my team mates need to do to see me is turn on the LCD panel and accept my request for video.

That’s not to say that the experience is perfect. I’d love it if the xbox video conferencing:

• Allowed each side to run video at full screen. I just don’t need to look at myself and when we go picture-in-picture (the LCD is also used for projection), the video’s not very useful.
• Allowed me to remotely, instead of locally, select zoom regions.
• Allowed me to control a camera that supported pan, tilt and zoom in hardware.
• Supported noise cancellation. As it is, I still have to place a phone call to get onto the speaker phone in the room. If we try using the headset as a roaming mike, the feedback makes it unusable.

However, for the $30 incremental cost of the camera + year of live, it’s a solution good enough that we’re using it more and more. Have I mentioned how much I love my xbox 360?

I’m supposed to be writing today, but John (my eldest son) is also doing some writing as part of his homework. However, after watching him struggle with just the topic (the phrase “Always aim for the moon. Even if you miss, you’ll end up among the stars” [which isn’t even the correct quote]) to try to write the fully-formed essay, I give him a little lesson about how I write. Plus, since I’m supposed to be writing, this blog post is an excellent avoidance technique.

When I write, I told my son, I have to write giant books starting from empty pages. I can’t just have a topic and start writing, I have to have something to break up the whitespace first. So, as a demonstration of this technique, I asked the fruit of my loins, an apple from my tree, for a topic. He said, without so much as a second of hesitation, “boogers.”

So, we started by brainstorming booger-related topics:

• can be dry and crunchy
• can be wet and chewy
• flick ’em
• eat ’em
• wipe ’em
• come from noses
• wipe ’em on somebody
• wipe ’em on tissue
• wipe ’em under something

The brainstorming is just a list of facts in whatever order I think of them that I know about the topic that I may or may not decide to share with my readers. While brainstorming, I don’t judge — I just type whatever comes up. After brainstorming, I spend some time rearranging my facts into some kind of outline to lay out my order and my main topics into which the facts fall:

• intro:
• what they are
• formed from dust and other irritants in the air
• can be dry and crunchy
• can be wet and chewy
• come from noses
• how do I get ’em out of my nose:
• Kleenex
• finger
• friend’s Kleenex
• friend’s finger
• what do I do with ’em now that I’ve got ’em out of my nose:
• flick ’em
• eat ’em
• wipe ’em
• wipe ’em on somebody
• wipe ’em on tissue
• wipe ’em under something
• straight blow in the shower
• summary
• overrun (although I’ve decided I don’t want in my finished piece)

During the outlining phase, it’s often the case that more facts come up and sometimes even whole categories of facts. As you’re forming the story, that’s when the gaps make themselves clear. At this point, I generally jump into the first fact, turning it into the first sentence, adding supporting sentences, transitions to the second fact and so on. Sometimes, though, especially with shorter pieces, I’ll write the summary to make sure I’ve got it in mind as the write the entire piece. This idea of the story that I want to tell is what Don Box calls “the spine,” and it’s the most important part. Once you’ve got the spine, everything else falls into place.

summary
Boogers happen to everyone and they’re good for you. However, when there are too many, you gotta get ’em out. I recommend that you use a combination of Kleenex and your finger (for those hard to reach spots). You should make sure to throw the Kleenex away and wash your hands, although the shower straight blow is a good alternative. You should never, ever flick or wipe your boogers on something besides Kleenex, because who wants to find them?

At this point, I’ve gone from a blank sheet of (virtual) paper to a place where I know the spine, the details and the ordering; most of the hard work is done.

Obviously, brainstorming + outlining + summary + details = completed essay isn’t exactly a unique perspective on the writing process. Still, how often does one get the change to turn boogers into a positive learning experience for one’s progeny? : )

I’ve been tagged a coupla times, so it’s time I fessed up with Five Things You Don’t Know About Me:

1. In college, I was in a fraternity and not just a geek fraternity, but an actual, national, recognized social fraternity (Phi Delta Theta). I figured I was geeky enough in high school, so needed a place to learn to at least hide my dorkiness. Obviously, I failed, but it was a very fun four years. : )
2. In college, I coded in Unix using VT100 emulation software via a modem to my school’s DECs from my Mac IIcx running System 7 (I worked two jobs all summer to earn half of the $6000 it cost me to purchase the thing in 1988). It was the combination of the best programming and best UI experience at the time (although on two separate OSes). After graduation and working a job for a coupla years where I programmed Unix all day, I needed to look at Windows 3.1 for the first time because I had an interview at Intel. I could only stand to use it for about 10 minutes. They hired me anyway as a Windows programmer and, thank goodness, it’s much gotten better. Windows is now my favorite programming and UI experience (and I’ve used both Unix and Mac OS X several times since then to make sure).
3. I am a fetishist; my fetishes are domain names and phone numbers. I can’t think of a cool domain name without a) checking to see if it’s available and b) purchasing it if it is (the one that sticks in my mind is clownporn.com, but that one was long gone). If I ever have a cool idea for an app, I must first purchase the domain name (I own appsettings.com and I just purchased 16 domain names the other day for another thing I want to do). Likewise, if I see a 7-digit phone number without a 0 or a 1 in it, I am physically compelled to surf to phonespell.org to see what the possible 7 and 8-letter words are (my old home phone number was 642-JOHN, the name of my eldest son). Of course, I’ve written my own program to do the permutations of numbers to letters, but phonespell does that cool dictionary lookup and grouping thing. I also added the phonespell support to Dave’s Quick Search Taskbar Toolbar Deskbar.
4. I have jumped out of a perfectly good airplane (not Alan Cooper’s plane).It was just before I got married and I took my best man. We both used parachutes. The fall was surprisingly quiet, but the stop at the sudden bottom was unpleasant.
5. The equal-rights-for-humans theme that sometimes pops up on this site isn’t because I’ve seen friends discriminated against and now I have to change the world (I don’t actually know very many people that are homosexual), but rather because I think it’s the right thing to do.

I tag Don Box, Chris Anderson, Michael Weinhardt, Tim Ewald and Ian Griffiths.

P.S. What’s the deal with the shape of the Pentagon and the Seal of the US on money (the eye at the top of the pyramid)? Damn you Doug Purdy for getting me The Illuminatus Trilogy when I’m supposed to be writing a book!

I tried the Xbox Video Marketplace on my 360 today. For 160 points ($2), I was able to purchase the season 2 premiere of Venture Bros (which is hilarious, btw) and 17% into the download, I was able to start watching it commercial free. Quality was high and I’m downloading Star Trek: The Enemy Within (a transporter accident creates an evil Kirk) for another $2 as I write this. The next experiment is a movie, but I’ll wait for the wife to come home before we decide which one to pick.

The experience was seamless. Recommended.

P.S. I think gays and lesbians have just as much right to get married and to be parents as heterosexuals.

Of course I have no credibility here (I’m part of the evil empire, after all), but I have to say, I’m really loving the Windows Vista Ultimate RTM. I know the Vista team takes a lot of crap for being late and for not being revolutionary enough, so I thought I’d let the Vista team know that I have yet to find something that isn’t just better in Vista than in XP. Here are a few things I really like:

• I no longer have to do Ctrl+Esc, R before I can type something to run (I’m a huge keyboard guy); I just have to type Ctrl+Esc and start typing. This savings alone has ruined me for XP. (And before you point out that I can just use Win+R, I don’t like the Windows key: it’s not on all keyboards and it’s not always in the same place.)
• If I want to search for a program in my voluminous start menu, I just do Ctrl+Esc and start typing. When the list of results contains my target, I press the down arrow to pick the one I want and press Enter when I get there.
• If I want to search for content on my computer, I just do Ctrl+Esc and start typing (once search is set to index my entire computer — I wish that were the default). If I want to be specific that I just want to search content or file name, I can use the “content:” and “name:” designators, e.g. “content:foo name:foo.cs”.
• If I want to find a setting in a particular control panel app, I open the control panel and start typing — the results point me at the specific control panel applet and page with that setting.
• If I want to find something on the internet, I press Ctrl+Esc and start typing, then press the up arrow (to get to the “Search the Internet” option) and press Enter, which brings up the results in my IE7 favorite search engine.
• If I want to find something in my large list of installed programs, I open the Programs and Features control panel and start typing (I found the renamed “Add and Remove Programs” control panel by searching for “uninstall”).
• Before you narrow my list of likes about Vista to “pervasive search” (which, obviously, I love), I also really like the sidebar. It’s amazing how often I glance over there to get some quick piece of info that’s always being updated for me rather than start some app, interrupting what I’m doing (e.g. lately I’ve been waiting with bated breath for MSFT to hit 30). I’m anxious for lots more sidebar gadgets.
• I love that the desktop is in the Alt+Tab list.
• I love the 3D Win+Tab list.
• The games, both new and old, are uniformly gorgeous.
• I really love the new look ‘n’ feel, including the animations and the new start menu, both of which I turned off in XP.
• I love that it just works on my 2-year old Dell laptop w/o any muss or fuss. I only have a Windows Experience Index of 2.0 because of my graphics card, but using Vista is still a very pleasant experience (and I have Aero glass around the edges of my windows and everything).
• I really love Windows Meeting Space. I’m a big user of Live Meeting because of my remote employee status and Windows MS is a simpler, cleaner, peer-to-peer version of the only parts of LiveMeeting I every actually used, i.e. sharing apps and sharing files. To have it included for free is huge.
• I love having Media Center included, too.
• I love that I can do picture slide shows from zip files as well as from folders.
• I like the new Sync Center, one-stop shopping for my offline folders (which I love) as well as managing my smartphone’s files.
• I really like the real-time thumbnail of apps when I hang the mouse over icons in the taskbar and in the Alt+Tab/Win+Tab list.
• I love that .NET 3.0 is included out of the box.
• I love that every app I’ve tried, including an app I originally wrote for Windows 95, just works.
• I love that I find new features all the time.
• As I’ve mentioned, I like the clearification.com site. In fact, I liked it so much, Mel and I want to see Demetri Martin live in Portland. Very funny.

Seriously, given the experience with recent pre-release versions of Vista, I thought I was going to just stick with XP. I’m so glad I didn’t. Vista rocks.

P.S. I’ll continue to desensitize/scare away readers with political/religious/social messages in future posts. Until then, Happy Thanksgiving!

There are a very few games I could call “great.” Doom (of course). Half-Life 2. Burnout Revenge. Mario Kart. And last week, I added another game: Gears of War. Wow. I’m almost exclusively a first-person-shooter person (although I never liked the Halo series), but GoW has converted me to 3rd person. It rocks.

The one flaw in GoW is that it’s too damn short! I’ve already finished the entire game on “casual,” so now it’s time to start over again on “hardcore” and begin the n-year wait for GoW 2.

P.S. I believe in God, but am not a member of any religion. I was confirmed Catholic, but am no longer one.

After a scant 6 months of service, my Xbox 360 yielded up the dreaded “to play this disc, put it in an Xbox 360 console” error (where do you think I was putting it?!?), which indicated a problem w/ the DVD drive. Ironically, this only became an issue after playing Gears of War for an hour or so (OMG is that a great game), even though it was happening consistently across my entire game library.

Calling 360 technical support yielded an offer of a repair, if I was willing to pay $140 (+ shipping) and wait 10 days for transit time. Having invested more than $1000 into my 360 and taken it into my home as a family member (ranking just below the kids but well above the dogs in the pecking order), I couldn’t abandon it. This part of my experience yielded a very important lesson:

Lesson #1: Modern-day consoles should be treated like PCs, not VCRs, and warranteed appropriately.

I’m so used to refusing the warranty when I purchase a piece of consumer electronics (and normally it is just a scam), that I didn’t even think to get the warranty on this one. On the other hand, I warranty ever Dell laptop I buy w/o a thought (and it has paid off many times). The XBox 360 (and I imagine the Play Station 3) are useful enough, that it’s worth the warranty fee when things go wrong and complicated enough that things are much more likely to do so, like your average laptop.

Luckily, my clever wife remembered that she’d purchased the 360 at Costco (she’s the one that brought it home — how cool a wife do I have?!?), which has a very liberal return policy. So, Costco took back my broken 360 and in return gave me:

• a brand new XBox 360 (which plays Gears of War consistently wonderfully)
• one extra controller
• one extra game (Xbox Live Arcade Unplugged Volume 1)
• my old HD w/ our saved games (instead of the new one)
• a $15 credit

You read that right — not only did they give me a new Xbox with more stuff in the bundle, but because the bundle was now cheaper, they refunded me the difference. I’m now hoping my 360 breaks every 6 months ’til they’re paying me to take the new one home w/ me… All of this leads us to lesson #2:

Lesson #2: Costco rocks.

In fact, Costco is such a great store, that I can ignore lesson #1, because I know that they’ll replace my Xbox again in 6-12 months if it breaks again.

P.S. I’m in favor of legalizing marijuana (although I’ve never smoked any myself)

P.S.S. I put in that postscript because I don’t want readers to think that I was scared off (or wised up, depending on your POV) from the response to my last post. : )

Since at least 2001 we’ve been stuck in a quagmire of missteps, indecision, corruption and the eroding of our freedoms. Some of us feared it would never end.

But the US House and Senate are now officially out of the hands of the Republicans, and that’s cause for much rejoicing. Let the balloons drop and the dancing begin! It’s a new age.

P.S. apologies to Mr. Petzold for ripping off his blog post, but when I saw it in my RSS reader, I thought that the above would be the subject of his latest essay and that we would finally have something on which to agree. It’ll be my luck that he’s a staunch Republican and I’ll hear about my misguideness tomorrow… : )

Back in writer avoidance mode, I did some research into PAYG phones for the boys based on some recommendations from friends, colleagues and Wikipedia. This is what I found:

Assuming I trust my kids to call whoever they want (so long as they pay), it seems clear that Net10 is the way to go. It’s effectively $10 for the entry-level phone (because it comes w/ $30 of free airtime) and $6/hour for more time after the first 300 minutes are gone. Plus, the Net10 phones show the amount of time left on the account, so the boys can monitor it themselves easily. Neither AT&T Wireless or Cingular has good reception in my area, so who knows what the reception would be, but for $40, it wouldn’t be expensive to find out and they sell them at my local Safeway…

From: Isaiah Okorie

Sent: Friday, October 13, 2006 08:06 AM

To: csells@sellsbrothers.com; csells@microsoft.com

Subject: XSellent!!!

Hi Chris,

I am  a .Net developer working in Ghana, West Africa. I have been reading your articles for a while now and listened to you whenever the opportunity came along. I think you have been very inspirational to my own work.

[csells] I’m happy to hear that. Thanks.

If you don’t mind, I would like to know how you are able to organise you work. How are you able to prepare for your conferences and still be a prolific author?

[csells] I think I’d sum it up as: Commitment + Fear. First, I commit to something, then I let the fear of bad consequences, i.e. giving a bad talk, missing my deadline, writing something inaccurate, etc, motivate me to do a good job. Unfortunately, this means I spend more time working then I’d like, but generally the results turn out pretty good.

What discussion groups, conferences, blogs (if any) are a must for you?

[csells] Since becoming an MS employee, I lurk on a few internal aliases based on the technologies I’m interested in. Externally, I hang out on slashdot.org, joelonsoftware.com and computerzen.com and that’s probably about it. It used to be lots, lots, lots more, but I just don’t have the kind of time I used to. As far as conferences go, I generally only do the PDC and my own DevCons.

How are you able to keep up with the changes? What books do you read?

[csells] I keep up with changes by a) a broad familiarity with as much technology as possible and then b) committing to using it because it feels like it’ll be the right thing and c) using fear to motivate me (recognize a pattern? : ). I read books on demand given the topic I’m into, and then it’s 3-5 books in a week for immersion. Frankly, after writing a few books, I’m a bit of a snob, so I don’t read a lot of technical books for fun the way I used to.

Now you work at Microsoft, how do you manage your ‘usual tasks’?

[csells] Honestly, it’s hard to keep up with the personal mail; I don’t do as good a job as I’d like. The web site stuff, e.g. blog, tools, spout, Genghis, etc, is catch as catch can. As soon as this last book is done (WPF Programming: The RTM Edition), I plan on trying to get some balance back into my life.

Many thanks for your inspiring hard work.

[csells] My pleasure.

I don’t want to download movies via Vongo or Amazon Unbox to my PC; I want to download them to my TV and smart phone! YouTube works because the videos are short, so watching them on my PV happens right now or not at all. Any movie or TV show service that doesn’t let me play the result on my media center or take it with me on my phone, I just don’t care. Does anyone want to watch 30+ minutes of video sitting at their desk or staring at their lap? I don’t get it…

In the world of Windows technical writing which has so much competition, there’s rarely any money involved, one dreams for reviews like these from KarstenJ:

″Tim Sneath walked into my office the other day and laid Charles Petzold’s Applications = Code + Markup on my desk.  I’m only to Chapter 7 of 31 chapters and I am riveted.  I already have that feeling when reading a great novel when you don’t want it to end.  It actually does read like a novel to me, with a narrative arch as it negotiates its methodical way through the WPF jungle of APIs.”

Congrats, Charles.

About 18 months ago, I asked for an intern and boy did I get one. He doesn’t want to be mentioned, but he’s done some pretty cool stuff with the site in his spare time (he’s also a very busy web development consultant):

1. Dug into what it would take to rebuild sb.com from scratch in ASP.NET 2.0 (although we differ on the moral implications of the license on Community Server 2.0)
2. Updated 404 page that tracks usage on dead/non-existent links, even missing URL #frags
3. Server-side link and client-side #frag forwarding
4. tinysells.com implementation (e.g. www.tinysells.com/4) and administration console (i.e. book co-authors)

#4 was very cool, because it enables me to put links into my writing that are easy for the reader to type and that are easy for me to update when the real URL changes (none of the other URL redirection sites allow administration post-facto as far as I can tell).

#3 is also cool, because of the primitive site authoring tools I use (FrontPage), so when I move spout/index.htm (the content of spout/default.aspx) to spout/archive.htm (the content of spout/archive.aspx), all of the links that folks have put into their own content are broken. Now, we’ve got a means for tracking when those links are broken and for forwarding them, even using my silly client-side name #frags. That even means that when folks form their URLs incorrectly (this one was never right and should always have been this) can be caught and corrected on my side.

Anyway, I wish I could tell you about this guy ’cuz he does great work and he deserves move business. Hopefully this post will shame him into it. : )

It’s easy to think that if you’re already got a high page rank in google, that you’ll get more than your far share of traffic, polarizing the internet into a small number of sites that get all the hits. Luckily, according to “Topical interests and the mitigation of search engine bias,” published in the Proceedings of the National Academy of Sciences, that’s not the case:

“Our result has relevant conceptual and practical consequences; it suggests that, contrary to intuition and prior hypotheses, the use of search engines contributes to a more level playing field in which new sites have a greater chance of being discovered and thus of acquiring links and popularity, as long as they are about specific topics that match the interests of users as expressed through their search queries.”

In other words, if you’ve got something relevant to say, the folks that care will find it. Yet again, letting the internet decide yields the best result.

Source: Is there a googlearchy?

I’m an avid 24 watcher and one of my favorite parts of the show (offsetting the fact that Jack never so much as cracks a smile let alone giving us a nice “Wahoo! I did it! I rock!“) is when one of the technies “sends her screen” to another computer. Man! I want that! It’s so often the case that I’ve got a bunch of morning news sites and documents I’m reading through that I get onto one computer in my house and want to send to another computer for reading (maybe it’s the computer downstairs or the Tablet), but there’s no way to do that. I want a little glyph next to the Minimize button called Send that lets me pick a computer to send the screen to.

And what does that have to do with the Comic Books Archive, which was archiving digital images of almost 3000 comic books at last count? These are folks that have figured out how to digitize a specific media and provide a specialized format (the Comic Book Reader format) and provide a specialized reader (cdisplay), which would make an excellent thing to send to a Tablet PC, along with PDFs, Word docs, web sites, 18,000 books from Project Gutenberg, and anything else that you’d like to share between your own computers or those of your friends and colleagues.

In April of 2005, Paul Thurrott mentioned something called “application sharing” that would enable sharing of individual apps via terminal services instead of entire winstations. I don’t know if we’re actually building such a thing, but I in addition to being able to reach from one computer to another to grab an app, I’d also like to send one.

Wouldn’t that make Jack proud?

Even though the 1st printing was just in May of this year, Windows Forms 2.0 Programming just entered the 2nd printing. Thanks for reading!

You said it couldn’t be done, but ATL Internals, 2e, has a review! Thanks, W.

I’ve seen some flack lately about how the Windows Media Center Edition-style computers haven’t changed how folks consume content. Man, it sure has changed mine. Sure, you can put a MCE box on your desk and watch TV from your chair, but who the hell wants to do that?

A MCE box belongs in a living room or bedroom somewhere or even in a server closet. In fact, while I have my MCE box attached to my bedroom TV, I use it as a media server for music, video, photos and recorded TV shows. My media is available at every PC in my home and at every TV w/ an MCE extender box (I have an XBox on one TV and an XBox 360 on another). This setup allows my media “room” to be my entire house and allows my family room media setup to consist of an HDTV and an XBox 360.

What’s not to love about that?

Microsoft is a sea of answers if only you can find the right person to ask. In my experience, I get a lot of those incoming questions, both internally and externally. Often, I don’t know the answer, but I can direct the email to someone closer, who will either know the answer or the right person to ask and so on.

Depending on how well a person in this chain is at answering this email, this process can take minutes or days, but it almost always ends up with the person that knows the answer within 3 emails. Often this chain involves an internal mailing list (lots of external questions end up on internal email aliases, insults and all : ), which doesn’t necessarily shorten the chain, but it does tend to shorten the response time.

I consider the ability to follow this chain to an answer one of the huge benefits of my industry — I wish I was able to tap into it in other disciples, e.g. health care, financial, home repair, etc. Likely these chains exist in other areas, too, I just don’t know the first link in the chain. I actually tried to establish a financial chain one time, but that just pissed off the guy who was always my first email. : )

I had my first on 10 experience today (I was following the links to the PhotoSynth stuff) and I have to say, I instantly fell in love with Laura Foy. I know that Erica Wiechers (of The .NET Show and MSDN TV) has a huge geekboy fan base (and it was fun to work with her @ MSDN), but Laura’s interviewing style and her personality made me subscribe to her interviewer-specific RSS feed on 10.

In fact, Laura makes me wish I did something besides developer-related stuff. What do I have to do to be interviewed by Laura Foy?!?

P.S. I wanted to title this blog entry “Laura Foy is a major babe,” but Laura is a fellow Microsoft employee and that would be inappropriate. Also, the whistling and cat calls would be way out…

I just realized that Avalon is getting a book treatment unlike any other topic in my memory:

• “Essential WPF,” by Chris Anderson, architect on the MS WPF team
• “Applications = Code + Markup,” by *the* Charles Petzold
• “WPF Unleashed,” by Adam Nathan of ”.NET and COM: The Complete Interoperability Guide,” *the* book on .NET interop and the correspondingly wonderful pinvoke.net.
• “Programming WPF,” by Ian Griffiths and Chris Sells. Ian’s depth of knowledge of graphics — down to the hardware — continues to amaze me.

User and GDI had Petzold. Win32 had Rector. MFC had Prosise. COM had Box. Indigo’s got no big names I’ve yet seen, but Avalon gets Anderson, Petzold, Nathan *and* Griffiths?!? It’s going to be a bloodbath in the market, but the readers are going to benefit. Why couldn’t I have picked a lightweight topic, like, oh, I don’t know, ASP.NET 2.0? : )

I had a very unpleasant afternoon trying to get NUnit working, so I thought I’d share my troubles and my solutions (such as they are). A search revealed a lot of folks with the same troubles, but precious few explanations or solutions. The NUnit Quick Start documentation does a wonderful job telling you how to write a simple TestFixture class with one or more Test methods (and even an optional SetUp method). However, as far as I could tell, there wasn’t any part of that tutorial that said “Hey! Add a reference to ‘nunit.core.dll’ as well as ‘nunit.framework.dll’ to your project or neither nunit-gui nor nunit-console will work;” you’ll get a System.IO.FileNotFoundException when you don’t have nunit.core.dll (the Exceptions Details menu item doesn’t help):

Also, when you start up nunit-console, you better darn well be in the current working directory of the test assembly as well as nunit.core or you’re going to get the same message in the console. Likewise, if you start nunit-gui. Further, if you just run nunit-gui, create a new project and then add an assembly, you better have known to save the .nunit project file in the same directory as the assemblies you add, or you’ll be getting the same message again.

And, as if that weren’t enough, you’ll get this message again if you add nunit integration as an external tool to VS05 (via the Tools | External Tools menu item) using the instructions in the docs. The docs say to use $(TargetPath) and $(TargetDir), but those variables expand to the obj directory on my machine (although that seems wrong to me), not the bin directory, and the obj directory doesn’t contain the referenced assemblies. I never was able to get a VS05 external NUnit tool to work.

Luckily, it’s very cool that nunit-gui doesn’t keep test assemblies locked and notices when an assembly has changed from underneath it, so that once I do get it started with the appropriate working directory, it works nicely.

As it turned out, there were a lot of ways to get that FileNotFoundException message and I’m pretty sure I found them all before finding any ways to actually make nunit work. None of these things are NUnit’s fault it’s damn hard to do dynamic assembly loading in .NET but it’s still on you to make sure NUnit is configured properly.

Finally, the tutorial shows but doesn’t say that you better make your test methods public. Since NUnit uses Reflection, it doesn’t need the classes or the methods to be public, but I guess they decided that was an interesting knob to let the developer turn. I’d have preferred to let the default permissions work (internal) to save myself typing, but that’s just a nit.

Mr. Petzold beat me to the punch on the Windows Forms 2.0 book and he’s going to do it again on the RTM Avalon book. However, such a thing is dicey, as Mr. Petzold points out.

It was in researching the Windows Forms 1.0 book when I grew to be scared of finalizing a book before the technology was finalized; that’s when they added AllowPartiallyTrustedCallersAttribute and it screwed up the entire No-Touch Deployment story. Toward that end, we didn’t ship the WinForms 2.0 book ’til after the .NET 2.0 bits went gold and we won’t ship the paper copy of the Avalon 1.0 book ’til then, either (although I understand ORA is going to be shipping early electronic drafts of our work as we do it). I have to sacrifice 2-3 months on the shelves to my competitors, but I get to be less scared of big, last minute changes.

It’s a judgment call, though. In this era of books with 12-18 month shelf lives, I can’t say Mr. Petzold’s not right…

I’ve been doing some design work with a small part of my new team for a few months now and we’ve gotten largely on the same page with each other. However, there were 20-some odd folks that we hadn’t done a good job keeping on the same page, so ChrisAn proposed an off-site. I proposed the format:

• 45-minute slots for each “bucket” of design functionality with the owner of the bucket leading the discussion (my boss, Adam, wanted to make sure that at least half of each talk was *not* lecture from the speaker). Each session was followed with a 15-minute break.
• 90-minute break-out sessions where each person had to pick their technology bucket and work with the owner to produce a 2-page functional spec and a 2-page technical spec.

If this format sounds like a tweaked DevCon to you, then you know where I got the format.

We started at 8am (1-2 hours before most folks start their day @ MS), so that gave us a little shared adversity to help build the team.

The 45 minute sessions made sure that the presenter had to get to the meat quickly, while the 15 minute breaks allowed folks some downtime to catch their breaths, check their email and chat with their brethren (this was a new team, so “bonding” time was an important element).

The 90 minute break-outs allowed folks to self-select into the bucket that most interested them, validated that we had the right buckets (any bucket w/ too few people would be cut, whereas any bucket w/ too many people would be split), helped establish the base-line for each bucket’s future (we used the off-site to kick-start the buckets) and gave the team a seemingly impossible task given the amount of time they had (shared impossible task == more team building).

Like your average DevCon, the “DesignCon” worked pretty well. We generated a ton of issues in each bucket that the owner hadn’t yet thought of and gave the entire team a kick-start down the road to shared pov. Also, since we had some folks from other, related teams and from upper management, we made sure we were communicating up and out as well as internally.

Of course, just as no DevCon is perfect, neither was the DesignCon, but if you’re looking for a way to get your team pointed in the same direction, I find the DesCon format a good one.

A coupla weeks ago, the AT&T wireless cell phone reception at my house went through the floor. I called up the nice folks at Cingular and they guaranteed me that my reception would improve if I moved my old AT&T account to Cingular (Cingular owns both, after all). When that didn’t work, I went to the mall, signed up for T-Mobile, went to my house and, when the reception was much better, had ’em move my phone number over. Since then, I’ve been moving my smartphone along with me (I have a QTEK 8500 on order, but my Audiovox 5600 is still the greatest thing to happen to me since my first laptop). Here’s what I’ve found:

• To get the data working (assuming you’ve selected that account option from T-Mobile), set up a GPRS connection that connects to the internet and uses “wap.voicestream.com” as the Access Point (no user name, password or DNS addresses). There’s no need for a proxy connection, but make sure that your IE connection options use the internet as its network (I mistakenly had it set to WAP at first).
• To use the phone as a modem for use in connecting to the internet, pair the phone w/ your computer using Bluetooth (make sure to put the phone into discovery mode so that Windows can find it) and then use the new COM port that Windows adds (COM4 on my machine) to set up a dial-up network connection, using “*99#” as the phone number (no user name or password). I get this working when I called T-Mobile and they walked me through the setup, even though the Audiovox isn’t a supported phone and the tech support guy had no documentation on one.
• This isn’t phone related, but once you’ve got a T-Mobile data plan, you should be able to use WiFi from your laptop at a T-Mobile HotSpot by using your 10-digit phone number as the user name and the last 4 digits of your SSN as your password (I haven’t tried this yet, but I plan to!).

Theoretically, I should be able to use ActiveSync via Bluetooth, but I haven’t figured out how to make that work yet.

So far, I’m loving T-Mobile, not just ’cuz of the rates and the features, but also because they seem to understand that some folks aren’t going to want to be stuck with the phones that they sell and they actually help you make them work. T-Mobile’s not the biggest network, but apparently that makes ’em try harder. Recommended.

While I don’t mind being called tacky by one of this generation’s best technical writers, I do mind the idea that the folks that would abuse the system would skew the Amazon reviews. While I don’t hide the fact that I ask people to post reviews for my book, I’ve always been proud that I’ve never asked them what kind of review to post and, when Amazon’s system had a hiccup recently, none of my books had any reviews posted by me (unlike 50% of the other books on Amazon).

So, the idea that folks would just post a review having not even read the book was something I never considered (and why you don’t want me writing your security subsystem). So, consider this offer rescinded. You can post a review on Amazon or not, good or bad, as you choose.

However, as to the signed copies, I still want you to have those. So, the first 5 people to tell me the 2nd word in the 3nd paragraph of prose on page 444, I’ll send you a signed copy. Whether you purchase a copy or just go to the bookstore and look up the word is up to you.

Wow. Two days of interviews for a contracting position at Google…

Update: Whoops — didn’t think of the ways to abuse this system. I’ve updated the offer here.

If you post a legitimate review on Amazon for Windows Forms 2.0 Programming before the 4th of July, 2006, I will personally send you my royalties for that copy of the book ($4.77 — don’t spend it all in one place : ).

You have to put your email into the Amazon review so that I can communicate with you about your address and Sells Brothers, Inc. can send you a check, but good review or bad, my royalties for one copy of the book are yours.

The first five reviewers also get signed copies shipped to their home (I’ll get Mike to sign it, too). Again, the email needs to be in the post.

The one where the brothers Sells and I travel to Ann Arbor, MI to see Windows Forms 2.0 Programming being printed. It’s well worth the trip, if you can talk the publisher into arranging it.

Years ago, Tim Ewald made an off-handed comment about how cool the real book printing process was and that I should take the boys to see it if I ever got the chance. Two weeks ago, we got the change and this is what we saw.

The printer for Windows Forms 2.0 Programming was Edwards Brothers, Inc. in Ann Arbor, MI. The boys and I took the 8pm flight from Portland, OR to Vegas, then the 11pm flight to Detroit, arriving at 6am, having gotten about 3 hours of sleep during the flight (the boys first redeye!). On the way out the door, we’d been a little rushed (I was trying to finish off the flooring in the new laundry room so that Melissa could have her washer and drier back after its long absence during the renovations), so had left all of the carefully prepared contact info and directions sitting in my office, meaning that the first thing we had to do was to sit in the airport near a hotspot and download driving directions. This and a trip to the restroom for a teeth brushing and a fresh shirt and we had caught our 2nd wind.

We picked up our car and had a very pleasant trip to Ann Arbor, where we stopped at Mike’s Coney Island for pancakes and omelets (I had the pancakes and my youngest surprised the hell out of me by ordering an omelet — they grow up so fast!). We arrived at Edwards Brothers around 7:30a (in some time zone) and learned that they had been in business for a little while longer than Sells Brothers, Inc:

Unfortunately, we’d arrived before our escort, the very lovely Ms. Cindy Rohraff, so she caught us napping in the parking lot around 8am. Still, as we entered the lobby, it was clear that they were as excited to show us around their operation as we were to be there:

After Cindy purchased caffeinated sodas (Microsoft has spoiled me enough that I hadn’t come prepared to actually *purchase* sodas…), we began our tour and the first thing we saw was a big basket of the rejected bits of my book:

As it turns out, these bits weren’t rejected on content, but rather on printing quality.

The size of the printing floor is enormous. It felt like 4+ football fields in there and I’m sure I saw at least 50 different books in various stages of production. In this picture of the boys and Daryl (in charge of printing our job), you can get some small sense of the size of the place:

For all those jobs, Edwards Brothers employees are constantly throwing away covers, inserts and “signatures” (bundles of pages that get stuck together to produce a book) that don’t meet their quality standards. In fact, I saw one guy throwing away what must’ve been 100 freshly printed book covers because he’d examined one of them with a magnifying glass and found a flaw. These guys are serious.

Next, we found our way to the input end of the printer, where they feed in 2-ton rolls of paper:

If you look closely, you’ll see that their are two rolls of paper connected here. Only one is fed through at a time, but when the first is out, the 2nd is spliced in automatically without ever slowing down the printing process, providing a virtual infinitely long roll of paper. A cache of paper is kept on rollers to enable the time it takes to splice:

When the splice happens, the rollers at the top and the bottom (not shown) get close together as the cache is used up and then after the splice, the rollers expand again as the cache fills up. That’s not to say that the printer doesn’t stop at all. When it’s running, the paper goes through the process so fast, the words and images are a blur, but whenever there’s a problem, the process grinds to a halt and restarts w/o issue.

After the cache, the paper feeds into the printing machine (or machines, depending on how many colors the output needs):

and comes out all printed:

The printing itself happens with ink that’s been spread over thin metal plates containing the laser-etched images of the book in 48 page sets, one plate for each side. The paper goes through the printer between the two plates. Here you can see Daryl changing the plates:

To support the ability to change the plates, the printer opens in the middle with hand cranks, which Daryl let the boys operate:

Daryl was one of the long list of people that bent over backwards to show us around and explain to us the process (Thanks, Daryl!). The plates themselves are shown here:

After the pages are printed, they’re rolled and cooled to set the ink:

After the ink is set, the paper goes into a machine that cuts it and turns it along three separate paths (you can see one of the paths continue over the top of the cutter):

Each path of paper is routed through a folding and bundling machine:

Once out of the bundling machine, the bundles are gathered together:

compressed (losslessly):

and stacked on pallets in sections (my book had 27 sections) for transport to the bundling department:

In my case, the cover:

and the color insert:

were printed by another vendor, but Edwards Brothers is fully capable of printing these elements. In fact, my book is pretty trivial compared to the tricks that the EB folks can do. I think next time, I’ll ask for a two-part cloth-bound hardcover with stained edges just to test ’em. : )

All 6500 copies were printed in one day and stacked over in the binding section of the printing plant (and again, notice the size of this place):

All of the sections were then stacked into the collating machine:

After this, my batteries ran out of power temporarily (they helpful staff at EB replaced ’em for me), so I can’t show you pictures, but once the books are collated and the spines bathed in glue at two temperatures (275 and 300 degrees Fahrenheit), the covers were attached and crimped and the books given “the wheel treatment” as they exited the machine on their way to the cutter:

The cutter was this very scary machine they called “the guillotine” and  was able to cut all three edges of my 1000 page book in a single slice and then stack the books into neat piles:

Not all the books survive the trip through the cutter (much like a real guillotine):

Once the books have been trimmed, they’re boxed and put on a conveyer to the shipping department. The shippers are responsible for lifting every single book (I apologized for my wordiness) and putting them onto palettes that are wrapped in plastic and hoisted by forklift:

The forklift stacks each palette in the warehouse for shipping:

That’s not all. The little bits of paper that were the edges of my book and the low quality copies are shredded and compressed into giant chunks:

Like the books, the cubes of paper are stacked in the warehouse for shipping:

The waste paper is shipped off to a recycler for use in other books, whereas the books themselves are shipped to distributors, like Amazon, Borders and Barnes & Noble. By now, the first of the pre-orders should be being fulfilled. The ones that aren’t sent off for sale are given to vain authors that need a physical manifestation of their work to really understand the amount of time and energy that goes into producing their book:

Special thanks go to Cindy, who was our most gracious hostess and to the staff and management of Edwards Brothers, Inc, for their work in producing such a high quality product. I also have to thank the boys for their infinite patience in indulging their father traveling to the middle west of our country to hang out amongst the stacks and stacks of books in progress. And, of course, thanks go to the readers. I hope you enjoy reader the book as much as I enjoyed working on it.

Seeing a reference to A C# Bedtime Story as a generic definition for .NET delegates in a recent DDJ article inspired me to post the new and improved version that takes into account C# 2.0′s anonymous delegate support. Enjoy.

ATL Internals, 2e, this time with ATL 8, is available for pre-order on Amazon.com. For those wondering what the world needs with such a book, I refer you to the preface:

.NET has hit the Windows programmer community like a tornado, tipping over the trailer homes of the ways that we used to do things. It’s pretty much swept up the needs of most web applications and service applications, as well of most of the line-of-business applications for which we previously used Visual Basic and MFC.

However, a few stubborn hold-outs in their root cellars will give up their native code only at the end of a gun. These are the folks with years of investment in C++ code who don’t trust some new-fangled compiler switches to make their native code “managed.” Those folks won’t ever move their code, whether there are benefits to be gained or not. This book is partially for them, if they can be talked into moving their ATL 3/Visual C++ 6 projects forward to ATL 8 and Visual Studio 2005.

Another class of developers that inhabit downtown Windows city aren’t touched by tornados and barely notice them when they happen. These are the ones shipping applications that have to run fast and well on Windows 95 on up, that don’t have the CPU or the memory to run a .NET application or the bandwidth to download the .NET Framework even if they wanted to. These are the ones who also have to squeeze the maximum out of server machines, to take advantage of every resource that’s available. These are the ones who don’t have the luxury of the CPU, memory or storage resources provided by the clear weather of modern machines needed for garbage collection, just-in-time compilation, or a giant class library filled with things they don’t need. These developers value load time, execution speed, and direct access to the platform in rain, sleet, or dark of night. For them, any framework they use must have a strict policy when it comes to zero-overhead for features they don’t use, maximum flexibility for customization, and hard-core performance. For these developers, there’s ATL 8, the last, best native framework for the Windows platform.

Mike and I submitted our last round of comments to the WinForms 2.0 book last night. The way it works is, after we submit the “final” manuscript, the copy editor has his/her way with it. Then Mike read all 1300 pages, making sure that the copy editor didn’t change the meaning of anything. After that, the publisher moves everything from Word to Quark so that they have the control they need to produce photo-ready copy for the printer and sends us a set of PDFs.

With the PDFs in hand, we both read the ~1000 pages again (the move to Quark puts in the final styles), looking for things that got messed up during the move between software packages or new things that we notice. Theoretically, we’re only checking for formatting, but I always take this opportunity to read the entire book all the way through with fresh eyes (which is why I made Mike do the copy edits — so I had some time away from the book to get fresh again). That yielded about 50 pages of comments for the publisher to apply, including dropping about 5 pages of content that didn’t add enough value to be worth the space.

And then the iteration begins. We submitted 50 pages of comments on round 1, they provide round 2. We submitted 10 pages of comments on round 2, they provide round 3. Last night, we submitted about 4 comments, none of which would ever be noticed if they weren’t submitted. I asked for a round 4 (just ’cuz I’m anal), but for all intents and purposes, we’re done. And how do we party animals plan to celebrate? We’re taking 90 minutes for lunch. Off campus! : )

By the time all is said and done, not counting the front mater or the index, chapters 1-19 and appendices A-F will be 960 pages. It was about 1300, but we cut and we tightened up the styles to keep it to 3 digits while still covering roughly twice the technology (WinForms 2.0 is about twice as full-featured as WinForms 1.x). We were careful about not cutting anything useful, but we were ruthless about cutting stuff that didn’t meet the bar. Hopefully you’ll like the results.

Windows Forms 2.0 Programming is supposed to be printed the first week of May, so you should order yours today!

When kids are young, they have no fear of computers or anything else. My eldest, when he was 2.5, knew how to detect what OS he was running (I dual booted Win2K and Win95 at the time), remember which OS his games needed, reboot, choose the non-default OS from the boot menu and start his app like it was the most natural thing in the world. Even though he couldn’t read, he learned all of the functionality of the app by choosing all of the menu items and pressing all of the toolbar icons just to see what they did. He had no fear.

Tonight, my youngest was working in Word, writing a paper that’s due tomorrow (of course). After he was finished digging through the thesaurus on the right-hand side, he wanted to close that part of the window, but accidental pressed the X to close the document he was working on (which, of course, he hadn’t saved). When he was asked if he was sure, he thought he was being asked if he was sure he wanted to close the thesaurus, so he pressed “Yes.”

The moment his document disappeared is when he learned to fear the power of the computer to throw away his work.

What did he do wrong? How do I explain it to him? What did we do wrong as an industry to teach my son to fear a tool meant to help?

This morning, I read about a $159 computer from a review on the PC Magazine site:

I called my local Fry’s, and while they were no longer have the $159 sale (apparently “quantities are limited”), they would be willing to sell me one for $171. While I was there, I got a 1GB memory upgrade and a 256MB ATI graphics card. Here’s the equipment I went home with:

• Fry’s Genuine Quality 3131 PC: $170.99
• 1.67GHz CPU
• 128MB of RAM
• 40GB HD
• 10/100 integrated Ethernet
• 56KB modem card
• 52X CD-ROM
• Stereo speakers
• Keyboard + Mouse (including roller ball)
• ATI Radeon 9550, AGP 8x/4x, 256MB DDR RAM: $94.99
• 1GB RAM SIMM(for a total of 1.1GB of RAM): $99.99

I then added an LCD panel and a DVD drive I had laying around. Total cost $365.97.

When I got the PC, it came pre-installed with Lindows, the Linux distro meant to look and act like Windows. And I gotta say, it wasn’t too bad. Then, because they ship a free CD that runs directly w/o an install, I plugged in Ubuntu, another popular client-side Linux distro which was also surprisingly easy to use. Neither was as familiar as Windows XP, of course, but they were both a lot easier to use then the last time I ran Linux.

At 12:04am, I started the Vista Feb ’06 CTP installation. At 12:44am, I was running Vista, it having recognized all of hardware (except the sound device) from my $366 PC, including enabling those cool “glass” effects and the nifty animations, integrated search and all the neat things you’ve read about in the Vista reviews.

I know I work for “the man,” but even so, I’m seriously impressed. The install was fast and seamless. The performance is way better than I thought it would be. And the little UI tricks are fabulous. I can’t do any media stuff ’cuz my audio device wasn’t recognized, but it was cool when I tried to play video and a DVD, that the Vista Media Center UI came up (my complete home entertainment needs are served with a coupla TVs, a Media Center PC and an XBox).

I know, I know, I got the OS for free, but come on! It’s still beta and it runs great on my cheapo PC! I don’t know what Vista’s going to go for, but I bet the whole she-bang (including LCD panel and DVD drive) could be had for ~$500 when Vista ships. Plus, I’ve only been playing with it for about an hour, but I already don’t want to go back to my XP boxes…

P.S. This post was composed and posted from “visto,” my new Vista PC.

Of course, when you’re learning to do something, whatever it is, you should check out how a lot of different folks do it. For example, the author of The Game learned to be a PUA from a variety of sources. One PUA guru of PM love is Brad Abrams and he regularly spills his guts onto his blog (plus, you’ve got to love his numbering scheme…):

• PM Tip #21: Sanity Will Prevail
• PM Tip # 32: Nothing kills excitement like ambiguity
• PM Tip #57: Write the agenda on the board
• Peanut butter and software planning
• PM Tip #73: The “Be More Visible” Sham
• Program Manager Wisdom #78: Reveal your stupidity

Enjoy!

Engineers are people, too, and appreciate pats on the back as much as anyone. In fact, many of us are so socially needy that we’re willing to trade “attaboys” for money (and hence the fuel that drives the OSS community).

The beauty: praise is cheap. Blocks of plastic, plaques, bowling night morale events, etc, all cost money and can be the cause of derision as often as pride. On the other hand, sincere praise freely given doesn’t cost a thing, but it’s often much more appreciated.

So why doesn’t praise happen more often? I think one reason is because we’re engineers, so we’re trained to focus on where our work falls short, often completely ignoring when it lives up to expectations. Also, sadly, it’s not uncommon for folks to want to take credit for themselves . However, as PMs, we have to remember that just because we give the presentation or write the status email doesn’t mean that we did the work. We need to be explicit about giving credit.

So, the next time you’re giving a talk, don’t say “And this feature does …” say “This feature, which Pete implemented, does this…” When you’re writing that status email, don’t say “We implemented feature XXX this week…,” say “Carol and Joe implemented feature XXX this week…” As soon as you do this, Pete, Carol and Joe know that you appreciate their work and that whoever you’re communicating with knows that they did good things. Appreciated team members are happy team members.

So, does that mean you should praise things you don’t necessarily appreciate, just to keep your team motivated? Absolutely not. As soon as the praise sounds empty, you’ve done more harm than saying nothing at all. Definitely look for opportunities to give credit, but don’t make stuff up that you don’t believe.

But what do you do to get praise for your own work if you’re busy doing all of this praising of your team mates? Nothing. Praise from yourself is called “bragging” and it makes you look stupid (I know this because I struggle w/ this constantly). Give your praise freely and let others do the same. If you’re effective, people will say good things and that’ll be enough.

I learned this way of reviewing artifacts from Cal Caldwell, a friend of mine from my instructor days. The technique is for doing code reviews, but I’m going to be using it later this week for some design docs. Anybody who recognizes this technique can chime in with what it’s called:

• Every reviewer gets a different “hat,” i.e. a POV that they adopt when reviewing, e.g. looking for coding guidelines, looking for readability, looking at a feature from an architecture pov, looking at it from a particular customer pov, etc. Anyone can have feedback on anything, but the idea is that with different folks wearing different hats, you get a greater coverage.
• Every reviewer brings review comments to the meeting, i.e. you reviewer before hand and only report at the meeting.
• Every reviewer must start with something nice! Too often, engineers focus on the negative. Saying nice cushions the blow and reinforces the good things so that they don’t get cut.
• Each piece of feedback will be logged (hopefully by the person that provides it) and spoken to the reviewee, but will not be argued with. If a reviewee disagrees, they keep it to themselves, asking only clarification questions to make sure that they understand the feedback. What feedback is applied it up to the reviewee and any follow up arguments happen offline.

That’s it. The best code reviews I’ve every participated in used this technique and I can recommend it highly for that. On Monday, we’re going to use it to get through a large number of design docs, so I’ll let you know how that goes.

I guess wikipedia is cool, but the wiki that provides a vital service in my life is pinvoke.net, which provides an enormous, user-contributed list of Win32 API mappings for .NET. I find it useful not just because folks are contributing tons of stuff I use, but also because I find it a wonderful place to drop code for my own later use, e.g.

• GetTempFileName
• CommandLineToArgvW
• SHAddToRecentDocs

This is the closest thing I’ve seen to a working code repository that is just as easy to contribute to as it is to use. Highly recommended.

P.S. I think this kind of functionality should be built into the SDK docs. I’ll ask ’em.

It’s very easy, as the PM, to not want to waste team time in a meeting, letting folks go when there’s still 30 minutes left. In fact, lots of folks will praise you for your short meetings. That’s fine if all of the work for that meeting has been done, e.g. everyone’s reported their status, all of the open questions have been decided, etc.

However, it’s often the case that in these meetings, other issues will come up to be discussed in future meetings to be scheduled at another time. Don’t let your concern for your team mates’ free time tempt you to let ’em go! It’s hard enough to get the folks you need together in a room. Once you’ve got ’em there, use ’em.

For example, if you’ve got the team together for weekly status that’s scheduled for 60 minutes, it often only takes 30 minutes. In that 30 minutes, you may decide that a subset of the team needs to get together for an hour design discussion on whether to spinning text boxes to your next software project. As a dutiful PM (aka “mom”), you’ll often find yourself saying, “Sure — I’ll set that up.” Then it’s your job to find an hour on everyone’s calendar while that issue remains open and the project drags on.

Don’t do it! Instead, peel off the folks in the status meeting that need to be in the “hour design discussion” and have the meeting right then and there. You’ve already scheduled the weekly status for 60 minutes, so you know those folks are free and just dying to get back to reading email in piece in their office — put ’em to work instead! Who the hell knows how long a design discussion is going to take anyway? It’s just as likely to go under an hour as over, so you might be able to wrap up the issue right then and there, skipping the need for another meeting altogether. Believe me, your team mates will thank you for that!

Savas showed me this great example from a book he’s reading. Consider this:

F = m * v

Using an imperative interpretation, this is a expression that, when evaluated, multiplies m and v, putting the result into F.

Using a declarative interpretation, this is an equation and is completely equivalent to the following:

m = F / v

The imperative interpretation allows me to execute. The declarative interpretation allows execution as well as addition reasoning.

Assuming the Sony Reader is cool, I still won’t have all the content I want and I certainly don’t want to repurchase all of my books. In the same way copyright law enables me to backup my CDs and DVDs, I want to “rip” my books and comics for electronic use. I’d like the same technology that the Google and the Amazon folks are using to digitize existing books (the folks that litter USENIX with copyright materials must have a cool setup, too). My understanding is that, unlike CDs and DVDs, which are easy to read via computer, books are not, so I’ll need a service where I can box up my books and send ’em for ripping, resulting in a shiny DVD filled with my words and images, ideally OCR’d enough to allow full text search. In fact, after a while, the book rip houses would have most books on file, so I’d only have to prove that I own a book and they could email me the electronic version, saving us both the shipping charges. In further fact, this is an additional service that Google and/or Amazon could provide, since they’re already “ripping” the books they sell…

I hate that indexes suck and that they don’t support full text searching across my entire collection.

I hate that I have to guess which ones I’ll need or want so that I can carry them with me.

I hate that I need a light to read them, potentially bothering the driver or a sleeping spouse.

I hate moving them, making shelves for them and searching for them on the shelves.

I hate that I can’t take notes in them — not even the ones I own — without breaking out into a cold sweat (although, to be fair, that’s more about my librarian mother than the book itself : ).

I hate that I have to buy a book twice if I want to listen to it instead of read it (and I hate that there’s no way to pronounce pictures or code).

I hate that if the local book store doesn’t have a book, that I have to wait for somebody to deliver it.

I hate that my local book store doesn’t have reviews of the book, whereas my on line book store doesn’t let me flip to whatever page I want.

The one thing I don’t hate about books is the content. That part triggers my thoughts and my emotions in me that are so strong, I put up with all the things I hate so I can get to it.

Why isn’t there an iPod for books (is it because iBook is already taken)? Why isn’t all print media, e.g. novels, poems, comic books, news papers, magazines, etc, available in electronic format?

In an ideal world, a PM would be able to get together with their team, lead the discussion ’til everyone agrees what they’re going to do and while they’re doing it, hang out on the beach answering the odd question on their smart phone ’til the work is scheduled to be done.

At Microsoft, we don’t live in an ideal world.

Instead, we have roving bands of PMs prowling the halls looking for resources, trying to get things done. Because this is an accepted part of MS culture, people actually listen when a PM shows up at their door to pitch their idea and ask them to help. And, so long as it fits into the broad goals they’ve set up with their boss and their other commitments, and it’s more fun then the thing they’re supposed to be doing, they often say “yes.”

This means that folks on your team often have multiple commitments that they have to decide between. It’s like when you get married or close friends, you’re going to have more than one family to visit at Christmas time. However, you have to put your blood relatives first, making them your top priority and squeezing in the other families when you can, e.g. Christmas Eve Eve.

As a PM, you have to know what the “blood relationships” are for each of your team members. Are you their second or third family? If so, you have to take “Christmas as celebrated on.” However, if they’re in your first family, then you take top priority and you should feel free to act like their mom.

Traditionally, it’s the mom’s job to make sure people are healthy and happy (doing stuff they like), making sure that they’re eating right (getting pizza during late night coding sessions) and that they’re getting special treats when they deserve them (public announcements praising their work).

Likewise, it’s the mom’s job to remind them of their chores (their task list), check their report card (make sure their tasks are up to the quality bar) and to guilt them when they forget Mother’s Day (keeping up with the schedule).

As the PM, you’re the team’s memory, the catch-all for crappy tasks nobody else wants to do and the one that makes sure everyone is working well together. You’re the glue and the conscience. If the teammates on your team aren’t waking up thinking of tasks you want done and going to bed hoping they’re making good progress on your tasks, then, according to MS culture, that’s your fault.

So, make sure folks are unblocked and happy, but also make sure they’re doing what you consider their top priority and that they’re doing it right and one time. Trust that they’re doing what they should be, but make sure they know what you think they should be doing and that they’re doing it right.

The downside is that such a world doesn’t scale without PMs at every level, but that’s why MS has PMs, Lead PMs, Group PMs and Product Unit Managers, all of them acting as the mom for their families.

Here’s a review you don’t get very often:

“Your WPF book is excellent. So good that I actually chose to read it instead of watching in flight entertainment from my trip to London in Dec… I liked it so much that I asked for some champaign, and continued to read it non-stop till I reached London from UK. Here’s a photo. Good job!”

I’m glad to here our book goes nicely with a glass of champagne, although maybe Parimal will change his mind when he sobers up or the jet lag wears off. : )

PMs often come from the ranks of engineers who’ve been “promoted” (aka taken away from the code to go to meetings). Many fight this trend, reverting to their old close-the-door-and-solve-the-problem habits to solve problems, which, as I’ve mentioned, doesn’t work at all well when you’re managing a team.

Even worse, a PM has to do something that’s very weird to most people — they have to help other folks get their work done before they tackle their own work. I call this “unblock others first.” This has implications:

• You have to be in constant communication with all the folks on your team via meetings, 1:1s, phone calls, IM, email, etc. However your teammates like to communicate, you have to be ready to receive and respond quickly. The longer you wait, they longer they’re blocked and the further out your ship date goes.
• You have to learn to be interrupt driven and good at switching between tasks or you’re never going to be able to swap into the tasks you’re being asked to help with and then back into your own tasks. This is very counter to engineering work, where you have to be able to keep lots of ideas in your head all at once while you work on a deep technical task and interruptions are the enemy.
• You still have to balance your interrupt-driven PM time with your concentrated technical time, or you’re never going to be able to stay technical enough to keep up with your team. This is the one I struggle with the most. How can I be responsive to unblock my teammates while still having uninterrupted time to myself for technical work?

This last question is the fundamental contradiction when you’re a product PM and it’s one that different PMs balance differently. Some swing a lot toward the technical and risk losing touch with their team and thereby building the wrong thing or missing their dates. Some swing toward the management, losing touch with the technology and losing the respect of their developers. Of the two, swinging too much toward the technology is the biggest danger, but only by a little.

I deal with this by trying to set aside at most a day here or there where I can ignore my team and concentrate on something technical, but I have a very hard time actually doing it. Frankly, I love the constant task switch that goes w/ PMing and I get bored if I go too long without it.

“Hi. My name is Chris and I’m a PM. Can I get a hug?” : )

At our last team milestone, we had stepped up the pace in the last two weeks to make sure that we were done in time for a demo by one of our internal stakeholders (demoing your stuff is a wonderful way to communicate, but having other folks build on your stuff to demo their stuff is even better [so long as they remember to mention your stuff]). When we decided to step up the pace, I let everyone on the team know that I was available 24/7 until the demo, providing all my contact numbers. I was actively working on a chunk of the implementation, so I would send out status and check-in mails whenever I had completed something, often in the middle of the night or early in the morning (I didn’t get much sleep for those two weeks). When folks had questions, I was there to answer them, day or night. I was working long and focused hours and I was making good progress against my goals to meet the deadline for the demo.

In other words, while I never once asked the team to double their work efforts, once we’d all agreed to meet the shortened deadline, I stepped up my pace, let them know I’d stepped up my pace and expected them to do the same. This is the same no matter what behavior you want, whether it’s working long hours (only temporarily, though, else you’ll burn out your team), showing up to meetings on time or getting powered sugar on your keyboard. Some individual members of your team may not change their behavior, but they definitely won’t if you’re not willing to.

Karen Gettman, my editor at Addison-Wesley, called and asked me a bunch of questions about the future of publishing yesterday. After our discussion, she asked if I knew anyone else and I volunteered to put a survey up on my web site.

To answer this survey, send the questions below and your answers to Karen.Gettman@AWL.com. Also, include your phone number so Karen can call to follow up (she finds the phone conversations to be most illuminating when it comes to really figuring out how people want to get to info — we spent a bunch of time talking about hardware and software for ebooks). Thanks from Karen for your help!

1. How do you learn about things to keep current in your job?
2. What questions have you recently had and how did you search for the answers?
3. How do #1 and #2 work well and poorly today?
4. How would you like your information “served up?”
5. What part of content (besides the content itself) do you value the most (name of its creator, form factor, etc.)?

Fundamentally, a PM’s job is to get things done. If you’re going to plan and ship while keeping your team happy, you’ve got to plan, ship and keep your team happy. All of this pre-supposes you can get things done.

Getting things done isn’t magic. For example, I’m sure everyone reading these words can get something done all on their own. However, when you’re a PM, you’ve got to lead a team to get something done and that’s a little trickier. Here’s what I do:

1. Identify a problem, e.g. I don’t like doing Sudoku with pencil & paper.
2. Identify a solution, e.g. put Sudoku into Windows.
3. Identify your customers, e.g. Sudoku freaks that would prefer a better experience than pencil & paper.
4. Figure out the folks that care one way or the other, e.g. the people that decide what goes into Windows and pitch your solution, either convincing them it should be done or convincing yourself it shouldn’t. In most cases, your solution will need to change a bit to match your agenda to theirs.
5. If you still think it’s a good idea, find the folks that need to approve of the work (it may be the same folks that decide) and negotiate what success looks like, e.g. a user of Windows can choose Sudoku from the Games menu of the next version of Windows and have a happy Sudoku playing experience.
6. Find the folks that need to help, e.g. the people that actually puts things into Window, and plan the work, e.g. write Sudoku, debug Sudoku, test Sudoku, get it into the manifest of files that make up the Windows setup, etc.
7. By now, you’ve got a group of people involved with your idea. At Microsoft, these people are called stakeholders, and form the team of folks getting things done, whether it’s approving the work, enabling the work, doing the work or using the work. With these stakeholders, you need to schedule the work. Scheduling accurately is a whole other topic, but to get things moving, you basically need an owner for each and every task in your plan and you need that owner to commit to a date, e.g. you (the PM) bill spec Sudoku by 1/1/06, Bob will write Sudoku by 2/1/06, Pete will test it as Bob writes it, etc. Also, if the work is more than a month or so, break it into milestones so that people see steady progress.
8. If these people aren’t enough to get the job done in a reasonable time frame (as determined by your schedule), you’ll need to get additional resources, either by hiring or convincing other people that already work with you to spend their precious time working on your idea.
9. Now that you’ve got a set of tasks and a schedule, you need to execute. That means making sure everyone’s got what they need to do their work, including time, tools, the right information, etc. This also means gathering information about how folks are doing and sharing it with the stakeholders (a lot of them, like your boss or his boss, won’t be doing the work, but will care about it). Finally, executing as a PM means holding the schedule up in front of the individual faces on your team every once in a while and “motivating” them into living up to their commitments, where “motivation” includes encouragement, bribery, shame, nagging, reminding them what problem you’re trying to solve so as to keep them on track, etc.
10. When you’ve met your criteria of success (which will involve more stakeholders, time, tasks and/or resources than you thought), ship it. Do not forget this step! I know it’s silly, but unless you’ve got an ever-decreasing list of tasks that shows you’re getting closer to a real ship date instead of further, you’ve lost one of your major executing motivations. In fact, getting close to a goal is so important for the health of your project and your team, that you should have as much shipping in your schedule as possible, which is why must non-trivial projects are broken down into milestones, each of which you’ll share with some set of your stakeholders, e.g. daily builds stay internal while betas are shared with customers.
11. After you’ve shipped, don’t forget to post-mortem. In fact, I like to do port-mortems after each milestone. This allows you to decide what went well and poorly so you know what to repeat and what to avoid in the future. In addition to increasing your team’s knowledge so that you can do better next time (or at least not do any worse), the post-mortem is a great time to really highlight the team’s accomplishments, making sure to point out the work that individuals did. People need to know that their work is appreciated. That’s not to say you need to plunk down a chunk of Lucite on their desk, but a simple “thank you” with specifics in front of a crowd goes a long way.

As an example, after the 2005 PDC, I wanted to make sure that Avalon and Indigo worked very well together. Obviously, that’s not something I can do myself (I have check-in rights to neither team’s source code). I’m not done with this work yet, but here’s how it’s coming along:

1. Problem: Avalon and Indigo didn’t work together during my PDC talk as I would’ve liked.
2. Solution: Getting a set of Avalon/Indigo technology samples into the SDK (a technology sample is minimalistic, the SDK already has a bunch of Avalon/Indigo application samples, which attempt to show something more akin to real-world usage).
3. Customers: Developers using Avalon and Indigo together.
4. Pitch: I made my pitch to the people in charge of the SDK samples for Avalon and Indigo. They liked the idea and became my first stakeholders. They also reminded me that WinFX included Workflow, which quadrupled the pairings of technologies, i.e. from Avalon/Indigo to Avalon/Indigo, Avalon/WF, Indigo/WF and Avalon/Indigo/WF, and required an extra stakeholder. They also reminded me that I’ll want to get someone from the SDK team itself involved, because I’ll want to make sure there’s a special section in the SDK samples that lists integration samples separately from the individual technology samples.
5. Success: A set of samples that show the “right” way to integrate the technologies and meet the standard sample bar of quality, e.g. they compile, they run, they pass FxCop, etc. This definition of success reminds us that the problem isn’t that we don’t have enough samples, but that the pieces of WinFX don’t work together well enough, which is why getting architects from each technology into the room together to decide what’s “right” (and changing the technologies appropriately) is the real job. Getting samples into the SDK is just the thing we’re doing to motivate this activity.
6. Plan: We’ve got a list of samples that cover integration scenarios, what technology pairing they each cover, who owns ’em, who’s authoring ’em and milestone dates, e.g. code complete, architectural review, submission, SDK drop release date.
7. Schedule: We composed the schedule by looking at the samples we wanted to do, picking the releases of the SDK that we wanted to hit (different releases had different features that we wanted to integrate together) and then backing it up from their, i.e. if we want to hit the Foo CTP, the submission deadline is n, we’ll need m weeks to turn around architectural feedback, so we need to be code complete and have the review on n-m, etc.
8. Resources: Remember that this project started with just me, but now includes a decision-maker (or two) from Avalon, Indigo, Workflow and the SDK as well as sample authors and point people to get individual tasks done. In addition, there’s my boss and the bosses of all of the folks doing the work that have to approve how folks spend their time, all of whom have to be kept informed and can have input to the process. Some folks are part of the team because they were convinced of the importance of the work and some are part of the team because their bosses were convinced and asked them to participate, but none of them work for me. It’s common for a PM to run a project composed entirely of people that don’t work for them, so sharpen up your people skills.
9. Execute: We meet semi-weekly to make sure we’re still on track and to identify any addition tasks and owners, e.g. adding the new section to the SDK, etc. Also, I’m the author of a bunch of the samples, so I have to meet the deadlines personally. As the PM, if I don’t meet my own deadlines, I’ve got no leg to stand on when I ask others to meet theirs.
10. Ship: We’re coming up on the first code complete deadline, which was delayed a bit because we needed a stable internal build of a WinFX CTP that we’re targeting to have the first set of samples placed into. Once we get the first set running on the right CTP, we’ll review, fix problems in the samples, file architectural issues we discover in the review process as bugs against the individual technologies, submit the samples to the SDK team for their quality check and out it goes!
11. Post-Mortem: We haven’t done this yet, but I things I expect to see come out of it is how to keep this work going. There are lots of combinations of technologies that we promote at Microsoft and there needs to be a way to make sure that they work well together, which, after all, was the whole point of this exercise.

Holy shit! I Macintosh that runs Windows!!!

“After Jobs’ presentation, Apple Senior Vice President Phil Schiller addressed the issue of running Windows on Macs, saying there are no plans to sell or support Windows on an Intel-based Mac. ‘That doesn’t preclude someone from running it on a Mac. They probably will,’ he said. ‘We won’t do anything to preclude that.’”

I can’t tell you how long I’ve waited for a laptop built by Apple running Windows built by Microsoft.

I’ve tried all the portal sites at one time or another (yahoo, google, etc), but none of them have ever stuck ’til now. Since I gave up on subscribing to blogs, I find myself surfing to two sites every day: slashdot.org and live.com. I like getting the news headlines and I really like the gadgets (not one, but *two* versions of Wahoo! [both of which end in “tris” for some reason…]).

It’s not perfect (the menu on the left obscures some text, there’s no auto scrolling while you drag and it doesn’t seem to like my smart phone), but it’s definitely “sticky,” at least for me.

On a recent mailing list discussion, folks posted a large number of URLs for mobile movie listing sites. Since searching for movies is one of the things I like to do on my smart phone, I did a quick compare and contrast, looking for the site that would give me a quick list of movies by my house. Here’s what I found:

Yahoo Mobile: once I chose my location, it showed me theaters, not movies in my location. I don’t pick the movie I want to see by theater, I pick it by title and time.

Google Mobile Search (XHTML): required me to enter “movies ”, but once I did, showed me a nice list of movies (in random order) along with running times and a rating (although I have no idea where the ratings come from), the genre and the maturity rating. Clicking on a movie showed me a list of times by theater, an address and a phone number. Once I save the URL into my smart phone favorites, this site could be handy…

Fandango Mobile: crashed when I entered my zip code.

Hollywood Mobile: asked for a zip code, then showed me a list of movies. Clicking on a movie didn’t show the theater closest to my house, so that dropped it from my list of potentials.

Metracritic Mobile: shows movie reviews, but doesn’t allow me to enter a zip code to show movies near my house.

Moviefone Mobile: can find movies by movie or theater in a cute tabbed interface. However, instead of showing me all the movies, it made me pick by category. Once I picked a category and a movie, it showed the local theaters and times.

IMDB Showtimes & Tickets: until this review, I’ve been using IMDB for my movie times. It’s designed for a desktop browser (they don’t have a mobile version I know about), but for a given zip code, you get all the movies, the IMDB rating, the maturity rating and the local theaters. You can also choose to look at the results by theater and easily change the day (e.g. tomorrow’s movies) or sort by theater. There’s a lot of scrolling around on a phone, but before this review, it was the one I used.

Of all of the sites, IMDB has the most capability, but it’s awkward on the phone. I think I’m going to see how the Google mobile movie search stands up to regular use.

I hate to say it, but indexes are the one place where I skimp when writing a book. I go round and round on sentence structure, figures, story, flow, coverages, what to cover, what to leave out, section headings and all of the other minutia that goes with writing a book, but I never bother with the index.

The index is one of those things where, as an author, you can write the index yourself, complete with page numbers (added manually) or your can let the publisher outsource it (although be careful when signing the contract — some publishers will charge the author the outsourcing fee!). So, for no work, I can get something that’s OK, but generates some complaints (maybe 1 out of 20 is about the index) and let Safari, Amazon and Google be the full-text search equivalent (even good indexes suck compared to that) or I can do a *ton* of work to reduce the number of complaints to 1 out of 30 (this is just a guess but it nicely justifies not doing the work, don’t you think? : ). As it turns out, the publisher will let you proof an index, but I have yet to figure out how to do that.

Anyway, that’s why most indexes suck. Sorry. I think you should read my books cover-to-cover, memorizing as you go, eliminating the need for an index anyway. : )

I know the phrase “building consensus” is a touchy, feelie term, but it’s the best description of one of the most important skills a PM can have. As a PM, you’ve often got responsibility but no authority, which means you have to spend time convincing everyone that the work you need done is in their best interests to do. Getting a whole group of people pointed in the right direction is the “consensus” part. The “building” part is how you get there.

One way to build consensus is to hole up in your office for days on end, drafting a plan down to the task and sub-task level, emerging only when you’ve got everything just right, presenting it to the team in one, fell swoop. I’ll call this the “engineering way” of building consensus, because it seems to be the first reflex of software engineers new to the PM world. Unfortunately, this way almost never works. The first problem with this technique is obvious: there ain’t no way your plan is going to survive contact with your team. They’ll question the highest level assumptions that affect the next level, which affect the next level and so on. Even if, eventually, your plan was 100% the right one, you can’t just jump to the end game w/o bringing your team along with you. The second, less obvious, problem with this technique is that, while you’re holed up in your office, the rest of the team will have splintered into factions, going in their own directions and building their own ideas of what the team should be doing which you now have to steer them away from.

My preferred technique for building consensus is what I’ll call “the big mess.” The idea is you get the team (or a representative sample of the team) into a room and you ask the leading questions, e.g. What are we trying to accomplish? How do we get there? Who does what? How does that fit into the bigger picture? How do we involve folks outside the team? I call this technique “the big mess,” because that’s how it starts and it only gets better through discussion and debate, led by the PM. One nice thing is that it’s usually a lot faster than holing yourself in an office, because you don’t have to make all of the planning decisions yourself (sometimes you don’t make *any* planning decisions), although you better be a fast hand at keeping track of the team consensus as it builds and playing it back periodically to make sure everyone’s staying in sync (Oliver Sharp turned me onto MindJet’s MindManager software for this task). One downside of this technique is that it keeps the decision makers on the team from doing anything else while you’re hashing through the mess, but the upside of this is that they’re not off pushing into a bunch of different directions.

As a tweak to “the big mess” to make it a bit less messy, I like to have a small proposal to seed the process. It’s always easier to start a discussion with folks telling you what they don’t like about an existing set of ideas then to start with a blank sheet of paper. If this “seed” comes from my mind alone, I stop myself from holing up in my office for days by giving myself only the hour before a mess meeting to prepare such a seed. I can mitigate some of the mess with a seed that I’m willing to dig up, but I actually make things harder if I show up with a fully formed tree that needs chopping down before the team is happy (see “the engineering way” of building consensus above).

If I want to show up at a mess meeting with a seedling, I can spend more time nurturing my budding consensus with a bunch of pre-meeting 1:1 meetings with the decision makers on the team to get their take. This only works if I’m able to come up with something that takes the majority of folks’ concerns and ideas into account and if I circle back with folks on refinements to the things we discussed before in the pre-meeting meeting. In this way, things are still a mess, but it’s the PM that deals with a large part of it up front.

Ideally, if you have a pre-mess mess (my name for the collection of pre-mess-meeting meetings), you can show up at the mess meeting to merely tweak and ratify, but this is a rare thing indeed. If I were you, I’d be prepared for the mess and use pre-mess discussions as a way to inform how you lead the discussion.

I think the title says it all: if you’re a PM, you’ve got to communicate. That includes to your team, your management, your partners and your customers. As I mentioned, I’m a big fan of getting people’s raw feedback with informal chats. I also like to schedule regular 1:1s with as much of the team as I can.

For folks not on the immediate team, I like to give them updates at the ends of milestones in the form of a PowerPoint presentation. The outline often looks like this:

• Milestone Goals
• What we did
• What we learned
• What’s next (goals and activities for the next milestone)

This lets folks give feedback on several levels, i.e. did we pick the right goals, did we do the right things, how do we apply what we learned, what should we do next, etc. It also gives them lots of places to tell them how their own work and requirements fits in with ours so that we can make sure we stay in sync.

For these kinds of presentations, you know you’re not having them regularly enough if management has to ask for one or if you can’t put one together in a day or two. You want folks to see you communicate proactively, not reactively.

For folks on the team, I like to send around weekly (or near weekly) status emails:

Goals

• goal 1 (100% done)
• goal 2 (50% done)
• etc.

Summary
In the last week, we …

Plans
In the next week, we’ll …

Tasks (from the bug database)
csells 452 12/13 Post PM Skill #1: Communication
…

I also like to post each status mail internally so that folks can skip a particular status or come into the team later and still get caught up quickly (a SharePoint site is excellent for this).

Often it’s the case that team members won’t read all (or even most) of your status emails. Don’t let that stop you from sending them! At the very least, it helps you keep your head around what’s going on and what needs doing. Also, it’s comforting for team members and management to know that status is available even if they don’t read the emails, because it lets them know that someone is watching the details. Plus, when someone asks a question that’s answered in the status, I tend to reply with the status email as an attachment, letting them know that someone’s all over things.

I’ve been a Program Manager (PM) at Microsoft now for about 2.5 years. Before that, I’ve been a managing contractor, a lead author, an engineering manager and a chief architect (both for commercial and shared source projects). Over a 12 year career, I’ve not only contributed to lots of shipping projects, but have lead several.

Most recently, I’ve been applying that experience to being a PM on a real Microsoft product team, which is its own unique experience. I’ve only been doing it for a few months, during which I spent a lot of time studying internal PM training materials and asking my exemplar PM brethern how they do it. At the same time, I’ve been helping a colleage get up to speed on just what it means to be a PM, so I thought I’d use this blog for what I think it’s best at — writing down what I believe and having people tell me where I got it wrong. So, consider these posts (like all posts on this site) to start with “in my opinion.”

A PM’s job is to ship the right thing on time and on budget, while keeping your team happy. There’s a lot in this sentence, so let’s break it down:

1. “ship” – first and foremost, the job of any PM is to start with a goal, either self-imposed or assigned, and ship an implementation of that goal. If you don’t ship, the rest doesn’t matter.
2. “the right thing” – unfortunately, shipping ain’t enough, you also have to ship the “right” thing by some definition of “right.” This is the most ambiguous part of the job, because any one goal can have many, many implementations and even the goal might not be the right one. My personal definition of right includes getting buy in from your team, your management, your partners (internal and external) and your customers (internal and external). You’re allowed to do whatever makes all those folks happy (and good lucking finding the intersection : ).
3. “on time, on budget” – this is all about execution. As a PM, it’s your job to lead your team through planning, scheduling, resource management and delivery.
4. “keeping your team happy” – this one is hardest for many engineers, because it involves keeping your team happy, focused and productive. There ain’t no rule book for this one, although I find a useful technique to be something widely known as “management by walking around.” Many folks won’t tell you how they really feel in a meeting, but if you can catch ’em on a phone call or in their office, 1:1, they’ll give you their real “gut,” which is vital to making sure that folks are happy, motivated and on the right track.

I’ve got more opinions about other vital PM Skills, which I’ll post as the spirit moves me, but hopefully at the rate of about 1/day ’til I’m dumped the entire contents of my brain, making room for other things. : )

WARNING: This is my political side bubbling over. If you only want fun stuff about my kids or technology, this post ain’t for you.

Clinton engaged in an consensual adult act in the west wing and endured the impeachment process.

Bush sics the NSA on us w/o due process, starts a war so he can look tough for his dad and continues to dismiss global warming as a myth. Why aren’t we impeaching his ass?

Mike did some last minute clean-up and checked in the files, so I’ve uploaded the code sample for the Windows Forms 2.0 book. Enjoy.

I packaged off the final chapters, figures and PDF files for submission of the WinForms 2.0 book this morning. Michael made it easy by fixing all the last minute nits I found, producing the PDFs and bundling all of the figure files together (he separated the graphics from the Word docs using a WinForms 2.0 program, of course!).

In spite of the fact that I’ve been working on long-lead prototype coding for the last month and Mike’s been moving to the US from Australia, we managed to get the book submitted a full 15.5 hours early (they meant midnight when they gave us a 12/16 deadline, didn’t they?!?).

I’m so excited to get the book in your hands, that I’ve asked Mike to check in the files he’s got checked out so that we can post the code samples ASAP. It’ll still be a while before the book is in your hands, though. We took 22 months to write it, but it’s the 3 months it takes to print it that always sticks in my craw the most for some reason. : )

Wahoo (2)!

I’m a huge fan of anonymous delegates, but I ran into a gotcha this morning when using anon delegates inside a for-loop:

class Worker {

  public event WorkCompleted Completed;

  public void DoWork() {

    Console.WriteLine(“Worker: work completed”);

    if( this.Completed != null ) {

      foreach( WorkCompleted wc in this.Completed.GetInvocationList() )

        wc.BeginInvoke(delegate(IAsyncResult result) {

          // Use wc from surrounding context

          int grade = wc.EndInvoke(result);

          Console.WriteLine(“Worker grade= {0}”, grade);

        },

        null);

      }

    }

  }

}

When I run this code, I get the follow exception:

System.InvalidOperationException:

  The IAsyncResult object provided does not match

  this delegate.

What’s happening, of course, is that the wc variable continues to change after the dynamic invocation happens instead of the value being stored away, one for each call to BeginInvoke, as I’d intended. One fix for this problem is to pass the value I wish I could take off the stack as the async state argument:

class Worker {

  public event WorkCompleted Completed;

  public void DoWork() {

    Console.WriteLine(“Worker: work completed”);

    if( this.Completed != null ) {

      foreach( WorkCompleted wc in this.Completed.GetInvocationList() ) {

        wc.BeginInvoke(delegate(IAsyncResult result) {

          // Pull the value out of async state

          WorkCompleted wc2 = (WorkCompleted)result.AsyncState;

          int grade = wc2.EndInvoke(result);

          Console.WriteLine(“Worker grade= {0}”, grade);

        },

        wc);

      }

    }

  }

}

This isn’t quite the elegant code I’d like to write with anon delegates, however. I can do a little better by creating a variable on the stack specifically for use in the delegate:

class Worker {

  public event WorkCompleted Completed;

  public void DoWork() {

    Console.WriteLine(“Worker: work completed”);

    if( this.Completed != null ) {

      foreach( WorkCompleted wc in this.Completed.GetInvocationList() ) {

        WorkCompleted wc2 = wc; // Copy wc for use in delegate

        wc.BeginInvoke(delegate(IAsyncResult result) {

          int grade = wc2.EndInvoke(result);

          Console.WriteLine(“Worker grade= {0}”, grade);

        },

        null);

      }

    }

  }

}

In this case, each time through the loop, a new variable is created on the stack specifically for that invocation of the loop and is therefore unchanged by the time the anon delegate is executed. This still isn’t quite ideal, but it’s not too bad.

If you could boot Windows Vista from a USB drive large enough for the OS and apps, like this version of Linux, and log into FolderShare for your data, you could use any computer that allowing booting from USB into a temporary terminal (although device drivers would be a challenge).

Today Michael Weinhardt and I submitted the final chapters of “Windows Forms 2.0 Programming in C#” for review. Mike has worked his butt off for the last 20 months to bring this revision about, taking a fresh look at every single chapter, not only for updates to the technology, but also for story. The book is far, far better than it was without him and he deserves your love and praise when the book is released (hopefully in April of 2006).

Since this is Mike’s first book, I imagine he thinks that most of the work is done. Here’s the list of things I sent him that still needs doing:

1. Mike will make changes to the chapters based on reviewer feedback, being careful to leave in change marks so I can see what he’s changed
2. I’ll review each chapter, approving or rejecting changes and making my own edits and comments and we’ll repeat this ’til we’re both happy
3. We’ll send everything by our post-reviewer-comment-application reviewer and apply his feedback like steps 1-2
4. I’ll update the preface after Thanksgiving, sending it by Mike and our final reviewer ’til we’re all happy (and in the process, you’ll put in your acknowledgements)
5. We’ll each update the frontmatter.doc to include dedications
6. I’ll update the TOC.doc to match our final TOC
7. Mike will pull out all of the figures into separate bitmap files (.bmp)
8. By 12/12, we’ll upload the complete final manuscript, both Word and PDF versions, and send it off to AW
9. Hopefully AW will send it along to Betsy, my most favorite copy editor ever, and she’ll mark it up, sending Mike the marked up pages to approve or disapprove each copy edit
10. AW will drop PDF versions of each of the final chapters to us, which we’ll submit change lists for
11. We’ll ask for updated PDFs, ’cuz the publisher traditionally only applies half of the feedback on each round, so we’ll repeat 10-11 ’til they get them all
12. Sometime in April of 2006, we’ll each get a big box of books with our names on the front cover, which indicates that they’re on their way to the book sellers, e.g. B&N, Amazon, Borders, etc. At this point, I’ll update the web site and post the sample code while Mike updates the app that tracks errata
13. People will send us email telling us how much they like the book to butter us up before asking a technical question. We’ll answer each question to the best of our ability and ask each questioner to post a review on Amazon.com
14. Some of the questioners will submit bugs in the book, which we’ll track in the errata database
15. When a print run has been exhausted (the initial print run will be between 10K — 20K copies, with subsequent print runs between 3K — 5K copies), AW will ask us for a list of changes for the n+1th edition. For some reason, they’ll always ask for those changes less than a week before they need them
16. AW will send us each a copy of the n+1th edition, which we’ll use to check that the errata we submitted was actually applied (for some reason, publishers don’t always apply all the changes we ask for), marking errata in the database as fixed in the n+1th edition
17. Repeat 13-16 for 18-24 months ’til everyone that wants a book on this technology has purchased it
18. Get started on “Programming Windows Forms 3.0 in C#,” repeating steps 1-17 after all of the chapters have been submitted for review

I figured Mike has had about 12 hours to enjoy being “done,” so it was high time to crush his spirit. : )

I’ve noticed that various prolific bloggers feel the need to tell me that they’re going to stop blogging for more than 24 hours. That’s one of the things I love about RSS readers: no matter how long someone goes away, so long as I’m subscribed, I here their every utterance.

On the other hand, what I’ve come to hate about RSS readers is that nothing gets by me. Keeping track of absolutely everything was exhausting, so I went cold turkey. I’ve been off #R since I repaved my machine a coupla weeks ago. I still surf to slashdot.org about once/day, but that’s it. No Scobelizer. No Don. No Ian. No Dilbert or Gizmodo or any of the 100s of other items in my OPML that I can’t even remember. No RSS reader of any kind.

So far, I’m enjoying the extra time on my hands. Have I missed anything?

Sloth of bears.

Army of ants.

Murder of crows.

Tribe of monkeys.

Embarrassment of richest.

What about geeks? Conference? Shy? Intelligence? Slather?

P.S. this site on collective nouns has a bunch of fun ones. I think I like “smack of jellyfish” best…

I just had the most amazing consumer experience and I just had to share it.

I was looking for the local Mom & Pop computer store in my area and I stumbled across www.puzzlecomputers.com. His site doesn’t mention a store, but I left him a message asking if he could upgrade my computer or point me at the local Mom & Pop. Not only does he do that kind of work, but he came to my house, picked up the two computers I wanted to use as parts, e.g. case, RW-DVD, HD, etc, recommended and purchased the new motherboard, CPU, memory and quiet power supply, put them all together (including modifying my old proprietary Dell case to fit), brought the whole thing back to my house and then spent another hour installing another HD I had lying around. The specs on the parts were 1GB of RAM (upgradeable to 2GB), 2.8GHz AMD processor and ABIT motherboard with all the trimmings.

The whole thing, parts, labor, delivery, etc. cost $400. Plus, he hauled away the extra parts so I don’t have to look at them. And when the drivers didn’t install right away, he was available for phone support.

Highly recommended. I wish all my consumer experiences were like this one!

I was playing around with a state machine workflow in WF and ran across something that I didn’t except. Apparently if you have a an activity that can be other than a singleton, e.g. inside of a loop or as part of a state machine workflow, then an activity can not be accessed by it’s workflow instance variable. For example, the following works just fine in a sequence workflow:

public partial class Workflow2 : SequentialWorkflow {
private void code1_ExecuteCode(object sender, EventArgs e) {
// Retrieve Comment property from typed event sink (generated by wca)
string comment = this.eventSink1.Comment;
    Console.WriteLine("Order approved w/ comment= {0}", comment);
  }
}

However, in the case where the activity can be executed more than once, it’s my understand that each time through, there’s a new activity object that’s different from the named activity associated with the workflow. To get a hold of the current activity, you have to traverse the activity tree, which you can access in a code activity via the sender’s parent property:

public partial class StateMachine1 : StateMachineWorkflow {
void code2_ExecuteCode(object sender, EventArgs e) {
// Retrieve Comment property from typed event sink (generated by wca)
    Code codeActivity = (Code)sender;
    IOrderService_Events.OrderApproved eventSink2 =
      (IOrderService_Events.OrderApproved)(codeActivity.Parent.Activities["eventSink1"]);
    string comment = eventSink2.Comment; // eventSink1.Comment will be unbound
    Console.WriteLine("order approved w/ comment= {0}", comment);
  }
}