Today, is my nephew’s birthday.  I had a great time a few weeks ago, visiting with my Brother’s family in Midland.  I got to play with Landon and get to know him a bit.  He’s a hoot.  He’s got a ton of energy, and just goes non-stop.  If you’ve ever seen the movie “Flubber” (preferably the classic), he’s alot like that stuff.

Happy Birthday, Landon!

[A quirk in my blog resulted in this post being posted much earlier this month, so you may have already seen it.  Today is his REAL birthday]

[humorously enough, another quirk caused the originally scheduled post to appear at the correct date (although a bit late in the day)]

Today, the little choncho turns 3! It really is unbelievable to me that she could be this old.  We woke her up this morning, and gave her one of her presents, some butterfly wings.  She really liked them.

I’ll take a rare moment to brag about her publicly, not because I think she’s better than your kid, or because I’m an awesome parent (I’m not), but because I love her and I’m so proud of her.  She is so awesome and sweet and polite (most of the time).  Even when she’s upset, she’ll say “thanks” when you hand her something.  She’s beginning to read, can do some simple math, and loves to draw and paint (the latter can become quite messy).  She builds the greatest things out of blocks and legos.  We went to Red Robin on Sunday, and I asked her to circle the items she wanted from the kids menu.  She circled mac ‘n cheese and oranges.

Happy Birthday, Choncho!

My brother-in-law posted a note on Facebook that was basically one of those silly things you do and perpetuate across the internet.  I usually don’t take part in such things, but this one seemed interesting, and I’ve been thinking about ways to jumpstart my blogging again now that the embargo on all the cool stuff is lifted.  So, I thought I would do it.  Here are the rules:

• Grab the book nearest you. Right now.
• Turn to page 56.
• Find the fifth sentence.
• Post that sentence along with these instructions in a note to your wall. (this was on Facebook, so it is referring to that wall)
• Don't dig for your favorite book, the coolest, the most intellectual. Use the CLOSEST.

So, it took me a while to determine which book was the “closest”, as my position is roughly normal to the bookshelf in my office.  I finally decided to be honest and pick the one that was really closest, but I will share another that was very close, as it is a good segue into future blogs.

The first (and official) one:

Semiconductor materials at 0 K have basically the same structure as insulators – a filled valence band separated from an empty conduction band by a band gap containing no allowed energy states (Fig. 3-4).

Solid State Electronic Devices, Ben G. Streetman

The second, and more relevant/interesting one:

The shim’s algorithm for picking a version in the COM interoperability scenario is much more straightforward – the latest version installed on the machine is always used.

Customizing the Microsoft .NET Framework Common Language Runtime, Steven Pratschner

What is amazing about this second one is that this is directly related to one of the features I’ve been working on for CLR v4 (and yes, that is actually the 5th sentence on page 56).  Namely, this feature is known as “in-process side by side” (or in-proc SxS for short), and was announced publicly at PDC last month.  This feature allows you to have more than version of the CLR loaded and running in a single process.

This feature is primarily a compatibility feature, targeted precisely at the behavior noted in the quote above.  When we use the latest version, we can break existing COM objects.  Not only because of breaking changes we make (of which the number is fairly small), but because of other, more subtle behavior dependencies.

Previously, loading a CLR version into the process locked the process to that CLR version.  Any other policy than “pick the latest” results in a load order dependency problem that can result in “for sure” breaks because COM components targeting newer runtimes cannot run on old runtimes.  So, clearly, that was the best choice of policies.

Now that we support multiple runtimes in the process (v2 and above), we can make a smarter, more compatible choice about runtime activation.  The precise policies are still being worked through, so I’ll avoid stating them explicitly, but you can imagine us being able to make a much better choice about what runtime to activate to run a given managed COM component.

I’ll be posting more about this feature and it’s implications soon.  Feel free to seed my future posts with questions in the comments.  Hopefully, this is the jumpstart I needed.  As for the “game” above, feel free to do it, or ignore it.  It won’t result in any difference to your luck, financial situation, or anything else.

I didn't get up an anniversary post yesterday because I was busy DOING stuff for my anniversary this year.  Unbeknownst to Becky, I arranged to take the day off. I sneakily got a late-morning massage appointment for her, and lined up a babysitter (thanks, Molly) so we could go see a movie in the afternoon.  Everything went off without a hitch.

We went to see the latest Indiana Jones movie, which we enjoyed very much despite the somewhat less than explanatory ending. We hadn't been to the theater to see a movie since Pirates II.  But, we both agreed that we aren't missing much except time alone and seeing the latest movies.

Some of my posts that I get the most recurring email/inquiries on are my various posts about the STDF (Standard Test Datalog Format) parser that I originally created as an experiment back in 2005.  After some help from a former collegue, I am pleased to announce that this is finally available on CodePlex as LinqToStdf!

It is a managed library for processing STDF files, and gives you a model to explore the data via Linq queries.  This means, you can leverage the wide variety of managed languages (C#, VB, F#, JScript, IronPython, IronRuby, Managed C++, Boo, etc.) to process the data in STDF files.  It also works in Silverlight!  It has built-in support for the V4 spec, but it's highly extensible and should be able to parse any version of the file format as well as custom records.  It can be configured to be highly strict and throw on format errors, or be robust in the face of issues that normal STDF processors would choke on to the point of being able to detect and repair corruption on the fly.

If that interests you, I'd love for you to drop by and take a deeper look at it and get involved in its ongoing development.  I've already got at least one person interested enough to contribute and ensure its success as a community project.  There is currently a "beta" release available, and hopefully we'll whip it into shape enough to call it v1.0 soon.

My hope is that this can be an adoption driver for .NET in the semiconductor industry and that through this project I can be an ambassador for the CLR in that area.

I've been playing alot with beta 2 of Silverlight 2, and I've been totally amazed at the scenarios it enables.  Working hard down inside the CLR engine, we're sometimes insulated from some of the innovation going on higher in the stack and it blows us away when we do get a chance to see it.

One of the very cool things in Silverlight is "Deep Zoom", which came from the SeaDragon project from Microsoft Research.  I decided to try it out myself on a very large panorama that I made a long time ago in New Orleans.  Unfortunately, the current toolset seems to trip over the large file size (20516x15291).  I'm trying to find out the real story behind the limitation.  All I know right now is that smaller files work.

So, I decided to try to slice it up into smaller, manageable chunks and just butt them against one another to simulate one large file.  The problem was that I couldn't find a tool to do this that didn't also trip up over the size of the file.  So, I wrote my own.  There are likely better ways to do this, this was just a quick and dirty attempt to make something that didn't totally crawl to a halt due to page faulting (or outright throw OutOfMemoryException).

The code below is what I came up with.  I use System.Drawing.Bitmap, lock the portions of the image I need, and do the data copying myself.  I ended up with this solution because GDI+ (DrawImage) seems to like to make alot of buffers (big ones in this case), and I couldn't fall back on good ol' bitblt because I couldn't get the right kind of data structures without more copying of the data.  This runs plenty fast and only takes up marginally more memory than it takes to represent the original and the size of one of the destination tiles.

Unfortunately, The MultiScaleImage does some weirdness with image that are butted up against each other, and you get as much as a whole pixel of "space" between them, depending on your zoom level. I'm still looking into other possible workarounds. So, it's wasn't ultimately useful, but I thought the code was interesting enough, and probably has academic usefulness.  So, enough talk, here's the code:

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Drawing;

   4:  using System.Drawing.Imaging;

   5:  using System.IO;

   6:  using System.Linq;

   7:  using System.Runtime.InteropServices;

   8:   

   9:  namespace ImageSlicer {

  10:      static class Extensions {

  11:          public static IEnumerable<int> Times(this int number) {

  12:              for (var i = 0; i < number; i++) yield return i;

  13:          }

  14:      }

  15:   

  16:      class Program {

  17:          [DllImport("msvcrt.dll", SetLastError = false)]

  18:          static unsafe extern byte* memcpy(byte* dest, byte* src, int count);

  19:   

  20:          static void Main(string[] args) {

  21:              var sourcePath = args.FirstOrDefault();

  22:              if (String.IsNullOrEmpty(sourcePath)) {

  23:                  Console.WriteLine("No source image path provided");

  24:                  ShowUsage();

  25:                  return;

  26:              }

  27:              if (!File.Exists(sourcePath)) {

  28:                  Console.WriteLine("Source image path doesn't exist");

  29:                  return;

  30:              }

  31:              var gridSizeStr = args.Skip(1).FirstOrDefault();

  32:              int gridSize = 4;

  33:              if (gridSizeStr != null && !int.TryParse(gridSizeStr, out gridSize)) {

  34:                  Console.WriteLine("Could not convert {0} to a valid grid size",

  35:                      gridSizeStr);

  36:                  return;

  37:              }

  38:              if (gridSize < 2) {

  39:                  Console.WriteLine("The grid size must be greater than 1.");

  40:                  return;

  41:              }

  42:              try {

  43:                  Console.WriteLine("Slicing {0} into a {1}x{1} grid.",

  44:                      Path.GetFileName(sourcePath), gridSize);

  45:                  Console.WriteLine("Loading...");

  46:                  using (var sourceBitmap = new Bitmap(sourcePath)) {

  47:                      Console.WriteLine("Source Image: {0}x{1}",

  48:                          sourceBitmap.Width, sourceBitmap.Height);

  49:                      var sliceWidth = sourceBitmap.Width / gridSize;

  50:                      var sliceHeight = sourceBitmap.Height / gridSize;

  51:                      Console.WriteLine("Each slice: {0}x{1}", sliceWidth, sliceHeight);

  52:                      int tile = 0;

  53:                      foreach (var row in gridSize.Times()) {

  54:                          foreach (var column in gridSize.Times()) {

  55:                              Console.WriteLine("Creating {0} of {1} ({2},{3})",

  56:                                  ++tile, gridSize * gridSize, column, row);

  57:                              using (var destBitmap = new Bitmap(sliceWidth, sliceHeight)) {

  58:                                  var sourceData = sourceBitmap.LockBits(

  59:                                      new Rectangle(column * sliceWidth,

  60:                                          row * sliceHeight, sliceWidth,

  61:                                          sliceHeight),

  62:                                      ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);

  63:                                  var destData = destBitmap.LockBits(

  64:                                      new Rectangle(0, 0, sliceWidth, sliceHeight),

  65:                                      ImageLockMode.WriteOnly, sourceData.PixelFormat);

  66:                                  unsafe {

  67:                                      byte* pSrc = (byte*)sourceData.Scan0.ToPointer();

  68:                                      byte* pDest = (byte*)destData.Scan0.ToPointer();

  69:                                      foreach (var line in sliceHeight.Times()) {

  70:                                          memcpy(pDest, pSrc, sliceWidth * 3);

  71:                                          pSrc += sourceData.Stride;

  72:                                          pDest += destData.Stride;

  73:                                      }

  74:                                  }

  75:                                  sourceBitmap.UnlockBits(sourceData);

  76:                                  destBitmap.UnlockBits(destData);

  77:                                  destBitmap.Save(String.Format("{0}_{1}_{2}.png",

  78:                                      Path.GetFileNameWithoutExtension(sourcePath),

  79:                                      column, row), ImageFormat.Png);

  80:                              }

  81:                          }

  82:                      }

  83:                  }

  84:              }

  85:              catch (Exception ex) {

  86:                  Console.WriteLine("Error processing image.");

  87:                  Console.WriteLine(ex.ToString());

  88:              }

  89:          }

  90:   

  91:          private static void ShowUsage() {

  92:              Console.WriteLine("Usage:");

  93:              Console.WriteLine("ImageSlicer.exe sourceImage [gridSize]");

  94:          }

  95:      }

  96:  }

I've been doing some app-building with Silverlight lately and exploring the limitations of the platform in comparison to the full desktop CLR and what that means for the Silverlight "ecosystem".  Those limitations can be summed up with 3 items:

1. Strict sandbox security model
2. Reduced managed framework surface area
3. No binary compatibility with libraries targeting the desktop CLR (eliminates the number of 3rd party components you can leverage).

I think #3 will begin to become a non-issue as more component providers provide builds for Silverlight. #2 can be broken down into 2 areas:

• Full technology areas that are unavailable on Silverlight (LinqToSql, WinForms, etc)
• Reduced/pruned APIs

The second is where my interest lies, and intersects with #1 (the new security model).  We've done extensive threat modeling against our APIs as well as automated tooling that has either removed (or made internal) certain APIs, or marked them as SecurityCritical, meaning they cannot be called directly from "user" code.

In addition, the security model requires safe, verifiable user code.  Normally when developing on the desktop CLR, unless you are specifically targeting a low trust environment, you can do whatever you like.

So, for this exercise, I pulled out my trusty STDF parser (blogged here and here).  I've used this project as a test vehicle for both v2.0 and Orcas, and it's served well as a project that leverages a large cross-section of features in the Framework, from high-level stuff like Linq down to expression tree inspection and further down to LCG/RefEmit.

In short, I was able to get the parser working without too much trouble. I felt like creating a source bed that intended to target both Silverlight and the Desktop should be an attainable goal.  You just have to switch your mindset from binary compatibility to source compatibility.

I combated the reduced surface area with extension methods, which worked quite well to centralize the "overload shims" that needed to be "Silverlight-only", as well as for a general refactoring tool.  My goal is to have all the desktop vs. Silverlight differences centralized into files that are either included or excluded from the build depending on which platform I'm targeting.  I wish you could create extension properties.  That would let me close all the surface area discrepancies that aren't caused by missing/irrelevant technology areas.

I was pleased that 99% of my LCG codegen stuff "just worked".  I make heavy use of Reflection.Emit via DynamicMethod to generate my record parsers based on attributes on the record classes.  The 2 problems I ran into were:

• Visibility restrictions - The new security model won't let my dynamic methods see internals.  I had used this ability to keep the API clean.  I'm still figuring out the best approach, but it was simple enough just to expose those methods.
• Verifiability - I had a few places where I was generating unverifiable code.  Some of these were my own codegen bugs, but others were just bad assumptions on my part.

This brings me to constrained callvirt, an interesting little IL tidbit I discovered in the porting process.  Calling conventions are subtly different between reference types and value types, and it also depends on whether the given method is actually overridden in the value type (which can lead to confusing breaks when that state changes).  In the v1.x days, you always knew the type you were dealing with, so it didn't matter that much and you could generally always create the right sequence of IL to make a call.  V2.0 introduced generics, which meant that you couldn't emit unified IL for both the possibility of reference types or value types.  This meant there needed to be a way to unify the IL for the 2 cases.  This is where the constrained prefix came in.  It allows you to write unified IL that works regardless of whether you're working with a value type or a reference type (think generics constrained by an interface, or calling a method defined on System.Object like ToString()).

Anyway, I was able to fix my unverifiable code by utilizing the constrained prefix.  It also simplified my codegen logic significantly in a number of places where I had different paths based on whether I was working with a value type or not.

All in all, I was pleased with the results.  I'll be posting a sample Silverlight app using the library when I get some UI stuff figured out.

I've been horrible with blogging lately.  But, I would be remiss if I  neglected to mention Peter's birthday today.  Happy Birthday, Peter.

Hopefully the thing that's been clogging my blogging pipes will be gone soon.

Some of my posts are really reactions to search queries that have previously landed on my blog.  If they did a search that got to my blog, but I know they didn't find what they were looking for, chances are they (or someone else) will do the same again.  And, if I HAVE the information they are looking for, it makes sense to just add the information, even if it's what I would consider well-known or common sense information. (common sense for software developers, that is)

One general search query I see again and again is something like "What is Action<T> for?" or "What is Func<T>?"

These are framework-provided, generic delegate types.  If you'll recall, delegates can be thought of as type-safe function pointers.  A delegate type really just captures a signature as "callable" object.  Leveraging generics to define delegate types that can capture common signatures is goodness, since they are very flexible and can be used by anyone.  This also aids in interop between different components, since a general signature is far more interopable than custom delegate types.

In v2.0, several functional-looking APIs were added that took delegates as arguments (think List<T>), so instead of adding a special delegate type for each API, several "generic" delegates were added to capture the "essence" of a signature such as Action<T> which takes T and does some action (returning void), Predicate<T> which takes T and returns bool (presumably doing some test against T), Comparer<T> which compares 2 T's, etc.

In v3.5, even more generalized functional patterns were introduced (used heavily in Linq).  And we added a bunch more Action<> "overloads" for functions returning void, and added Func<> "overloads" for functions with a return value.  (I use overload loosely since these are classes and not methods) These patterns dropped the semantic "meaning" of the delegate, and just went straight to the idea of capturing a signature.

These framework-provided delegates are useful for using in your own code rather than creating your own.  Whether you leverage the Linq-centric, super-generic Action/Func pattern, or opt to consume the more meaningful v2.0 Predicate, Comparer, etc. is up to you.

A twist on Bill Cosby's humerous show,  the other day I said the following to my daughter:

I'm sorry, donkeys don't stick to the refrigerator.

Taken out of context, Becky thought it was pretty funny. Here's the context: I was playing with Jenna in the kitchen the other day, and she was playing with 2 plastic donkeys as well as some refrigerator magnets.  After seeing how the magnets stuck to the refrigerator, she tried to do the same with the plastic donkeys, which didn't work of course.

Well, my old-school buddy Jason turns 32 today.  Jason and I have been friends since pre-school.  We pretty much attended every year of school together, all the way through our undergraduate years.  Here's a picture of me and him (Jason on the left... I don't know what the heck I'm doing) at one of my brother's birthday parties.  He was the friend I got to invite.

Happy birthday, man.  Go play some slaughterball today for me.

It's Jenna's 2nd birthday!  Wow, I can't believe it's already been 2 years.  Here's one of the pictures we took yesterday for our Christmas cards.

That was really fun.  I don't have a nice flash, so I had to resort to auxiliary lighting.  All things considered, I think they turned out pretty well.

Jenna constantly amazes me with what she knows.  She was playing with some blocks this morning and I asked her how many blocks she had.  She said, "Let's count.  One... Two... Three... Four."  Wow.

She's counted as high as 20, and can say the entire alphabet.  She loves to play with toy animals and make them talk with each other.  She loves to play "knock knock", where she'll close a door, we'll knock and she'll let us in, grab our hand and pull us in for a "visit".  Fun times.

This release was exciting me before I made the move to Microsoft, and getting to be a part of it has made me even more excited about what we're giving our customers in this release.  If you're not familiar with Visual Studio, it is a suite of software development tools for creating just about any application or library you can think of.  I'll be writing more about this release in the coming weeks, but for now, go to www.microsoft.com/vstudio and check it out!

Vista's search rocks, but sometimes you're not interested in searching through the gigabytes of file contents, you just want to search on filename.  Good ol "dir /s".  But, you don't need to give up the indexed goodness for this.  Just use some of the special search syntax: "name:[string you're searching for]" in the search box.

I certainly don't want this to turn into a video blog of fish, but I got some more video of the fish in our stream, and it's so unbelievable to me as someone new to this area that I simply must post it.  I've also done some tweaks to my custom Silverlight player as well as used some different encoding techniques (I haven't decided whether I like them yet).

Again, enjoy me sounding like an idiot.

[UPDATE:] The way I have embedded the player this time seems to prevent it from showing in most RSS aggregators. click through to my blog to see the video.

So, the salmon are running in our stream.  They're really big.  I caught this video today of a smaller female (I think).  Hopefully I'll get some bigger ones on video soon.  This is also an experiment with Silverlight.

Oh, by the way.  I'm like giddy with the thought of salmon in my stream, so I sound like an idiot.

I wish I had time to come up with more concrete information (examples/code) in this post, but I don't have the time to work that stuff up.  I did think it would be useful for people searching for solutions to this problem, so here it is in all its ambiguity.

I was playing with expression tree inspection and dynamic interpretation the other day, when I hit something that I was sure was a bug.  I was inspecting an expression tree, identifying "branches" of interest, and generating lamdba expressions from them on the fly.

You might do this to break up an expression into separate units of execution to spread across multiple processors (a la PLINQ), or to replace parts of a tree requiring local execution before passing off to another layer to be transformed into another domain like SQL, or whatever.  In any case, I was doing it.

I found that if the type of the expression was a value type, I could not create a lambda expression returning object from it, even though there is an inheritance relationship.  You get a fairly straightforward, but perhaps surprising exception.

After some back and forth with the Linq team, I discovered that this was by design.  In the case of value types, the boxing operation required to make an object must be represented by a unary convert expression. The solution is to wrap such expression trees with a call to Expression.Convert(expression, typeof(object)).

Today is my 1-year anniversary at Microsoft.  I've been having a blast working on all kinds of crazy stuff including but not limited to:

• Silverlight
• VS 2008 (Orcas)
• Windows Vista
• Windows Server 2008 (Longhorn Server)

And, Seattle has turned out to be a really fun place to live.

Today is my buddy Dave's birthday.  Here's a picture of him from a few weeks ago when he visited, which was a blast.  I've really missed Dave since we moved to Washington, so it was awesome that he could visit.

Luckily, Halo 3 is coming out soon, so we'll be hanging out alot more virtually.

Happy Birthday, Dave!

An interesting pattern I've seen emerge since the early releases of Orcas is what I might refer to as "delegate properties".  What I mean by that is a property (or field, I suppose) that returns a delegate.  This pattern has some interesting implications.

First, in a language that treats delegates as directly callable objects, this pattern looks just like a method (someInstance.TheProperty(args)).  You can't tell the difference (although VS gives you different intellisense) by looking at a callsite like this. Among other things, this leads to some interesting naming issues.  Do you name it like you would a method?

Second, it opens up opportunities to do some really powerful (and slightly insane) hybrid inheritance models.  Think about a virtual delegate property that has both a getter and a setter, now think about trying to predict what that delegate will do when you call it.  It doesn't sound like something to recommend as part of a public API, but I think there are some interesting scenarios there.

If I come up with something interesting and useful, I'll let you know.

Today is our 8 year anniversary.  Eight years seems like a really long time!  This past year has been a crazy year for us.  We've moved across the country, away from all our friends and family.  And, through it all, Becky's put up with all my crazy shenanigans.

Thanks, Becky.

Three of my good friends came to visit in the past couple of weeks.  My friend Peter, who I met in the 5th grade (if I recall correctly) visited again last week.  Due to a bizarre coincidence, his wife had a one-week job in Bellevue, which is here on the east side of Seattle.  So, I got to hang out with him, which was a blast.

This week, my buddy Dave was here.  Dave and I played trombone together in college.  His visit was also somewhat coincidental, but I won't go into the details here.  He stayed with us and we hung out and we had all manner of good times.

While Dave was here, Jeff (one other trombone friends from college) came down from Bellingham to hang out for an evening, which was super-fun.  In another bizarre coincidence, his wife Bethany went to high school with Dave, so there was some reminiscing there as well.  Bethany's mom came along for the ride as well, and schooled us all in a game of Wii Sports bowling.

I was really bummed that these visits occurred right after our big vacation, which meant that I really couldn't afford to take a couple of days off to enjoy them.  So, sorry again for that guys.

We got back from our big summer vacation a few weeks ago, and I've finally got all my photos processed and uploaded.  Here's the collection that combines the Cape Cod and Texas parts of the trip:

We had a really great time, aside from the ridiculous hassles of air travel.  Jenna got to meet her 2 cousins, and WE got to actually spend time with my brother and his family, which was something that was limited due to the sickness we had during our Christmas visit.

If you have been following my series on delegates, you may have experimented with open-instance delegates and perhaps found it difficult to create an open-instance delegate for a value type.

If you'll recall, an open-instance delegate has an extra first parameter, used to pass the instance used for the invocation.  What's not made explicitly clear is that this first parameter must be passed by reference.

For reference types, you've automatically got a reference, but for value types, this must be a "ref" parameter.  For instance, a delegate type used as an open-instance delegate for Int32.CompareTo would have to be defined something like:

delegate int IntCompareToDelegate(ref int instance, int other);

Otherwise, you'll get a System.ArgumentException when you try to bind the method to the delegate, giving you the ever-helpful error message: "Error binding to target method".

There are lots of underlying reasons for this, both from a calling convention perspective, as well as a side-effect perspective.  But, you can simplify it by thinking about modifications to the instance.  If you passed by value (creating a copy that the method acted on), any changes made to the instance by the method would be lost because they happened to a copy.

In most cases, value types are immutable in the framework, but you could run into issues with your own types.  And, again, this isn't the only reason for this restriction (take a look at the IL generated for a value-type method call to get some more ideas).  It's just the easiest to understand.

If you'll recall, Orcas extension methods, which are similar in concept to this, do not follow this pattern and are subject to the infamous value type copying problems.

I know, 2 picture-only posts in a row.  I couldn't resist this one though.

I was helping a friend with a problem recently.  He was taking a set of serial web service calls and doing them in parallel to save time, and was not up-to-speed on the best approach for that.  Once he settled on an approach, he realized that since his web service calls were being wrapped in an abstraction layer, he didn't have the Begin/End asynchronous call methods that are provided by the proxy class.

"No problem, just wrap them in a delegate".  The compiler automatically gives you Begin/EndInvoke methods in addition to the synchronous Invoke method.  And, you're guaranteed not to mess up the implementation because it's all provided by the CLR!  Just one of those things you might forget if you find yourself in the same situation.

After my last few CLR posts, I've had a couple of private inquiries regarding the usefulness of closed static delegates.  To bring everyone up to speed, a delegate pointing to an instance method needs a "target" instance to operate on (we'll get to open instance delegates later).  A static method, needs no such target, so we can leverage the "space" used for the instance case to carry around another object of interest.  We call a delegate with a provided value for this space "closed over the first argument".

For example, let's say we have a static method that does some operation on two numbers.  For simplicity, let's just say it adds them.  Our silly class and method might look like this:

public static class NumberFunctions {
   public static double Add(double first, double second) {
      return first + second;
   }
}

Normally, a delegate for this method would look like:

public delegate double BinaryOperation(double first, double second);

But, we're going to create a closed static delegate, which means we're going to "burn" the first argument into the delegate itself, so it's not needed in the delegate signature.  Instead, we'll use the following delegate signature (I didn't spend much time thinking up these names, I hope they make sense:

public delegate double ClosedCall(double other);

So, how do we create the delegate?  Normally, since C# (pre-Orcas) doesn't have syntax for creating closed static delegates, you are forced to use one of the Delegate.CreateDelegate overloads:

ClosedCall addToOne = (ClosedCall)Delegate.CreateDelegate(
        typeof(ClosedCall),
        1.0,
        typeof(NumberFunctions).GetMethod("Add", BindingFlags.Public | BindingFlags.Static));

Of course, we just spent 2 entries looking at a helper that can do this for us (I'm not claiming this is better, I just want you to be able to see what's happening):

ClosedCall addToOne = DelegateBinder.Bind<ClosedCall>(1.0,
        typeof(NumberFunctions).GetMethod("Add", BindingFlags.Public | BindingFlags.Static));

Now, a call to addToOne(someNumber) will yield the result of adding the supplied argument to one.  This is a contrived example, but you could imagine taking a method (perhaps generated on the fly via LCG), and "attaching" an instance to it via the first argument.  Then, being able to call it many times with different subsequent arguments, or passing it to another component that would provide the rest of the arguments.  In this way, you get the benefits of not having to keep track of an instance, without having to own the API for the instance.  Additionally, you could "chain" delegates together so that many arguments are captured in a stack of delegate calls, allowing closure-type semantics at the cost of some stack space (although since C# has closure support, you'd never really need to do that).

What's really cool is that with C# 3.0's Extension Methods feature, we now have language support for creating early-bound closed-static delegates.  If you bind a delegate to an extension method (using the regular syntax for an instance method), you will get the exact IL for creating an early-bound closed static method without our fancy helper class.  Let's see how that would look.  Let's use a different example to keep us on our toes.  Here's a helper function that creates email addresses:

public static class StringExtensions {
   public static string MakeEmailAddressWithAlias(this string domain, string alias) {
      return string.Format("{0}@{1}", alias, domain);
   }
}

Notice the "this" in front of the first parameter, this tells the compiler that the method should be considered when resolving method calls for string.  We'll use one of the delegate types provided in Orcas. Now, here's how the bind looks:

string fooDotCom = "foo.com";
Func<string, string> makeFooDotComAddress = fooDotCom.MakeEmailAddressWithAlias;

string email = makeFooDotComAddress("bar");

So, the result is that email will be bar@foo.com.

Hopefully, through these contrived examples, you can see the scenarios that closed static methods provide, as well as learn how you can create one the easy way with extension methods in Orcas.

In my last post, I showed a nifty way of constructing "early-bound" delegates using LCG.  Here's the same helper class implemented without LCG:

public static class DelegateBinder {
	public static TDelegate Bind<TDelegate>(object firstArg, MethodInfo method) {
		return (TDelegate)Activator.CreateInstance(
			typeof(TDelegate),
			firstArg,
			method.MethodHandle.GetFunctionPointer());
	}
} 

This one is quite a bit simpler, and extrapolating from what we learned last time, it's easy to see what's happening.  Hopefully, you are already familiar with the Activator class.  Basically, this just shows the managed call chain that produces a function pointer to a method given a MethodInfo.

I really like the LCG-based implementation, but only because of my love of DynamicMethod.  It's pretty complex, and aside from opportunities for caching, doesn't really have anything over this implementation. This one is just plain simple, and would have a single-line implementation if I hadn't put some line breaks to avoid formatting problems.  It does, however, highlight the annoyingness of having to work around the compilers' "helpfulness" when it comes to delegate construction.  If only I could just call the constructor directly.

It is worth noting that this doesn't work in the Silverlight 1.1 alpha or the compact framework (or XNA for that matter), neither of which expose RuntimeMethodHandle.GetFunctionPointer().

In a previous post about delegates, I discussed the following interesting cases of delegates:

• Closed static
• Open instance

See the previous post for the full explanation, but these basically open up some interesting dynamic scenarios.  The problem is that C# and VB do not expose syntax for constructing these in an "early-bound" fashion, that is using the special constructor on the delegate type rather than Delegate.CreateDelegate (which more or less binds via reflection).

For most scenarios this is not a huge problem, but there are some performance considerations and other issues to consider that I don't really want to dig into at the moment.  One sufficiently important scenario is testing early-bound invocation.  If your language doesn't support something, how can you test it?  Well, you can write the whole test in IL, but that is not a terribly maintainable proposition.

Another option is to only write the part you need in IL.  Unfortunately, C# doesn't allow you to write inline IL, but you can use Reflection.Emit.  And, since v2.0, you can use LCG (Lightweight Code Generation) via DynamicMethod.

The trick here is to understand how delegates are instantiated.  Delegates are just classes like any other.  They inherit from MulticastDelegate (typically).  The special part is that the runtime provides all the implementation and they have a special constructor.  Here's (approximately) the constructor signature for System.Action<T>:

public Action(object o, IntPtr method)

Object? IntPtr?  What the heck? Well, it's not as bizarre as you might think.  The object is simply the first argument for the invocation.  This allows binding to a particular instance ("this" for instance methods, arg 0 for static methods). The IntPtr is a pointer to the method.  "Pointers?!!?!?! in managed code?!?!" you say?  That's right, a pointer.  An object is easy enough to come by, but where do I get the pointer?  Well, the pointer can be easily retrieved via the ldftn opcode.  It loads the address of a given method (described via a token in IL, and a MethodInfo in Reflection.Emit).

Lets cut to the chase.  Here's a little class that can bind a method to a delegate type and allow you to provide the first argument (you'll need System, System.Reflection, System.Reflection.Emit using statements):

public static class DelegateBinder {

    public delegate TDelegate Binder<TDelegate>(object firstArg);

    public static TDelegate Bind<TDelegate>(object firstArg, MethodInfo method) {
        DynamicMethod dynMethod = new DynamicMethod("PassthroughBinderImplementation", typeof(TDelegate), new Type[] { typeof(object) }, typeof(DelegateBinder));
        ILGenerator gen = dynMethod.GetILGenerator();
        //load the first argument
        gen.Emit(OpCodes.Ldarg_0);
        //load the address of the method
        gen.Emit(OpCodes.Ldftn, method);
        //create the delegate
        gen.Emit(OpCodes.Newobj, typeof(TDelegate).GetConstructor(new Type[] { typeof(object), typeof(IntPtr) }));
        gen.Emit(OpCodes.Ret);
        return ((Binder<TDelegate>)dynMethod.CreateDelegate(typeof(Binder<TDelegate>)))(firstArg);
    }
}

With this class, you can dynamically construct all the early-bound variants (ignoring variants for signature relaxation) like so:

using System;
using System.Reflection;
using System.Reflection.Emit;

public delegate string Passthrough(string str);
public delegate string BoundPassthrough();
public delegate string ProgramPassthrough(Program p);

public class Program {
    static void Main(string[] args) {
        Console.WriteLine("Open Static:");
        Passthrough ospt = DelegateBinder.Bind<Passthrough>(null, typeof(Program).GetMethod("StaticImplementation", new Type[] { typeof(string) }));
        Console.WriteLine(ospt("Hello World"));

        Console.WriteLine("Closed static:");
        BoundPassthrough cspt = DelegateBinder.Bind<BoundPassthrough>("Hello World", typeof(Program).GetMethod("StaticImplementation", new Type[] { typeof(string) }));
        Console.WriteLine(cspt());

        Console.WriteLine("Open Instance:");
        ProgramPassthrough oipt = DelegateBinder.Bind<ProgramPassthrough>(null, typeof(Program).GetMethod("InstanceImplementation", Type.EmptyTypes));
        Console.WriteLine(oipt(new Program("Hello World")));

        Console.WriteLine("Closed Instance:");
        BoundPassthrough cipt = DelegateBinder.Bind<BoundPassthrough>(new Program("Hello World"), typeof(Program).GetMethod("InstanceImplementation", Type.EmptyTypes));
        Console.WriteLine(cipt());
    }

    public static string StaticImplementation(string str) {
        return str;
    }

    public Program(string payload) {
        _Payload = payload;
    }

    string _Payload;

    public string InstanceImplementation() {
        return _Payload;
    }
}

So, there are certainly cases that will break this, most involving incompatible signature issues between the method, delegate, and the first argument.  But I didn't want to make things more complicated for an example. Besides, the point of this is not really to give you some neat tool (you'll probably never need to do this), but to give people a better idea what the compiler is doing for you when you create a delegate.

One of my most successful comedic performances has got to be my rip-off of Dana Carvey's Grumpy Old Man character from SNL.  It was fun to pretend to be old.

Last night, I really felt old.  I was overseeing the youth as they played a variant of hide and seek, and I realized that there was something going on that I had never experienced.  The youth were using their cell phones to call each other and brag about their hiding places and trash-talking with the seekers about how they were never going to find them and such.  It was so interesting.  When I played hide and seek as a kid, not even our parents had cell phones!  Now everyone has them.  It was just a bizarre revelation.

Today is the MIX07 keynote (watch it live right now).  Scott Guthrie is currently on-stage spilling the beans about what's been going on here.  He just announced that Silverlight (v1.1) includes a cross-platform (Mac/PC at the moment) version of the CLR and the .net framework. I'll be talking about this alot in the coming months.  It's incredibly exciting stuff.

The NetFlix guys are on-stage showing off a demo of their new over-the-web movie viewing experience.  I hadn't seen this demo before. Very cool.

Scott just did his chess demo where the CLR engine plays chess against the IE javascript engine.  Very funny.

Scott just demoed cross-platform debugging (Running a Silverlight program on the Mac and hitting a breakpoint inside VS running on a PC).  Fantastic.

Scott's doing his airline demo.  I love this one because he starts with a cheesy "Hello World" app, and ends up with a fully-functional airline flight schedule viewer with crazy animations of planes flying around.

Scott just announced open source Ruby for .NET (IronRuby).  He's developing a Silverlight app with Ruby on the Mac with standard Mac tools.  Good job, John.  Now he's showing the dynamic language console, that gives you an interactive REPL console with Intellisense that can use any of the dynamic languages, or even mix the languages together on the fly.  All in the browser.  Freaking awesome.  I think alot of people missed the announcement about the DLR (dynamic language runtime) that anyone can use to build a dynamic language on top of .Net.

Wow, I've seen the MLB demo, but I hadn't seen the version running on the mobile phone!

In all the busy-ness of the last week or so, I neglected to announce that my brother-in-law Ben and his wife Nicole had their baby.  Congratulations to them.  We're looking forward to meeting Cormac Anthony Patterson in person this summer.

This weekend, I mowed my lawn for the first time since we moved here.  It needed it pretty bad, but I have been putting it off.  I just need to get used to cutting the grass when it's wet.  Mowing in the northwest is quite a bit different than mowing in central Texas. You can boil the differences down into the following:

• Temperature
• Central Texas - Pretty much sweltering at any time you need to mow.
• Seattle - I had a light jacket on.  I've never mowed when it was so cool out.
• Moisture
• Central Texas - You can usually wait until the lawn is dry to mow
• Seattle - No such guarantee that your free time will line up with a time where the grass is dry
• Grass Type
• Central Texas - All the lawn I've ever mowed have had st. augustine grass.  Wide, stiff blades.
• Seattle - Most grass around here is very fine, soft blades. (which makes for quite a mess when it's wet)  In addition, there is alot of moss in the grass, especially after the rainy season.
• Natural Variable Obstacles - Things that can move that you have to worry about running over.
• Central Texas - Fire ant mounds could get big enough to cause issues, as well as some pain if you weren't careful.
• Seattle - Pinecones can be big enough to cause problems.  Mole hills are also a new threat, especially since they often contain rocks large enough to be problematic.
• Cutting height
• Central Texas - You pretty much want to keep the grass as tall as possible so that it can retain moisture and keep from dying in the sun.  I usually cut on the highest setting
• Seattle - Most people I have observed cut it very low.  I started pretty low, and then raised it so I could get it through the tall spots without stalling the mower due to wet clumps of clippings bogging down the blade.  I think I need a sharpening, or a more powerful mower.

Right now, it kind of looks like a bad haircut. We'll see how it looks after the blades stand up again, and all the clippings die and turn brown.  It'll probably need another once-over soon to even things out. I was just happy that the mower fired up without difficulty after having been drained of it's vital fluids for the move.

For some reason, when I'm typing (and especially when I'm coding) I often conciously attempt to capitalize numbers under certain conditions.  For some reason, my brain thinks that there's a difference.  For instance, if I was typing HttpV4Implementation, I would probably end up with HttpV$Implementation because if there had been a letter there instead of a number, I would have capitalized it.  Does anyone else have this problem?  It's really frustrating because I often retype it several times making the same mistake each time before finally realizing what the problem is.

I think this may be caused by my handwriting style, which seems to be typical of engineers, where all letters are in captial form, but differ in size to indicate capitalization.  I've seen this referred to as "smallcaps".  Oddly enough, I didn't pick this up in college as an engineer.  I decided to start writing that way in junior high after noticing how cool my granddad's handwriting was.

Jeff and Bethany brought Micah down and stayed the night with us Friday night.  It was really fun.  In my opinion, Micah did awesome for his first trip away from home.  We watched The Bourne Supremacy on HD-DVD.  We wanted to watch The Rundown, but I couldn't find it on HD-DVD.

After the movie, we fired up the Wii, and played Wii Sports.  Jeff and I played boxing for the first time, and we are still sore from it.  It was an unbelievable workout.

Many people are lamenting loosing an hour of sleep last night.  I, for one, welcome our new GMT offset.  When you're in school, loosing that hour is rough, but in the last several years, I've really grown to appreciate extra light in the evening.  You can get so much stuff done when it's light out (particularly stuff that needs doing outside).  As a parent, I've also become less annoyed at loosing sleep.  Just 1 hour?  Big deal.

Now that I live in Washington, extra light in the evening is far more desirable.  During the shortest days of the year, it was getting dark at 4:30!  Lots of people prepared me for the gray, rainy days of winter here, and that really hasn't bothered me.  However, I wasn't prepared for the short days of winter. I really hope they make daylight savings last all year.  But, I'll be happy with the few extra weeks we get now.  Last night, it was still plenty light at 7pm (I don't recall when exactly it got dark).  Now, I can't wait until the summer when it's still light out at 10pm.

One of the great benefits of moving to Washington has been that we've been able to hang out with my college buddy Jeff Flint and his wife Bethany.  In fact they are coming down for a bit this weekend.  Today is his birthday, so Happy Birthday, Jeff!

Here he is posing for a recent spread in the REI catalog.

I saw the following web address on a flyer in the breakroom: www.tacomaopera.com.  My brain didn't split it up as "Tacoma Opera", it read it as "Taco Maopera".  Rats, and I was thinking it was another Mexican food place to check off as being not good.

I'll take a break from the technical posts for a moment.  Friday night, I helped out with a youth lock-in up at the church.  It was just like old times (except no spitting ice down the stairs).

The youth group at our church is decidedly smaller than at our church in Austin.  But, it makes sense because the actual church is much smaller than our church in Austin.  There were about 8 guys there (the girls were elsewhere).  We pretty much played video games all night.  We had 2 Wii's, a PS2, an XBox and an XBox360.  We also played some (outdoor) capture the flag.  It was a variant that I hadn't played before in Texas, and I didn't really understand it.

The highlight of the night was linking the xbox and the 360 and playing some 4 vs. 4 Halo 2.  I don't like to brag, but I did pretty well.  Mainly it was fun because they were trash-talking pretty bad about how they were going to beat me.  One game in particular (4v4 Team Slayer on Beaver Creek) I lead my team to victory with 35 kills and only 3 deaths.

It was cool to connect with the guys in that way. They are having a "ski day" on Wednesday, and I'm bummed that I have to work.  The whole concept of a day trip for snow skiing is completely foreign and bizarre to me.

Yup, it's that time again.  Today is my birthday.  I was lucky enough to get a Wii, which has been quite enjoyable.  Now I just need to get the component cables so I can stand to look at it. :)

The couch that we ordered over 2 months ago was finally delivered yesterday.  When we moved into our house here, we picked out a couple of couches...  a less-expensive, fold-out sleeper for the upstairs living room, and a really nice, non-sleeper for the big downstairs room where we spend most of the time.  The sleeper arrived shortly after we ordered it, but the nice one was delayed multiple times.

We spent our first 7 years of marriage with really old couches that my parents had when I was growing up.  They were so old and broken down that we decided not to bother bringing them with us to Washington.  It's very nice to have a sweet couch (it's nice to have a couch at all).  We made sure to get one long enough that I can lay on it without my head or feet having to be on an armrest (something I rarely experience at 6' 2").  It also sits up nice and high so you don't have to feel like you're climbing out of a hole when you get up.  Becky's feet don't even touch the floor when she's sitting on it.

So, we still don't have power, but things are looking up.  Let me give you the rough timetable so far.

• Thursday, Dec 14th ~8pm: Wind starts picking up. Lights begin to dip occasionally.
• ~10:30: Power goes out.  Ticked because I was in the middle of a Halo match.
• ~11:30: By this time, the wind is really blowing.  The sound of branches breaking off can be heard occasionally throughout the surrounding woods.
• Friday, Dec 15th ~12:30am: The wind is blowing like crazy.  The gusts are bending the trees to an alarming degree.  We decide we should move downstairs in case one decides to fall.  This wakes Jenna up and she decides we are playing some kind of game.  She spends the next several hours honking our noses.
• ~2:00am:  I am VERY concerned about falling trees.  With each gust, the sounds of breaking trees can be heard.
• ~4:00am:  Jenna is finally asleep.  The wind seems to have subsided.  We go back upstairs to be comfortable.
• ~morning: Damage is surveryed.  Nothing major.  Check around the neighborhood.  Nothing terrible.  Patiently wait for power to be restored.
• ~noon: It's getting cold.  I look for some firewood.  All I find is soaked through.
• ~3pm: still no warmth.  We decide to bail.  We call the Flints and head to Bellingham.
• ~7pm: We arrive in Bellingham, warm up, and stay the night.
• Saturday, Dec 16th: Head back to our house to check on the cats.  The daylight reveals the devestation of the infrastructure.  Trees are down everywhere.  Powerlines are a tangled mess.  The power's going to take a while.  We make sure the cats are OK, and head back to Bellingham.
• Sunday, Dec 17th: Attend Jeff's church and locate a generator that meets our criteria.  Big enough to run the furnace, small enough to fit in the trunk.  Head back to the house and fire it up.  Becky took Jenna to a friend's house while the house warmed up.
• 8pm: the house reaches 60 degrees, our criteria for staying the night, so Becky brings Jenna back and we put her to bed.
• 10pm: the house reaches normal temperature.
• Monday, Dec 18th 12:30am: The furnace stops working and the house begins cooling fast (the structure itself has not yet heated up to normal)
• 1:00am: We head to Becky's friends house and spend the rest of the night.
• Daytime: Jenna and Becky hang out at her friends house, and I go into work to see about arranging furnace repairs and do other errands in addition to keeping work from falling too far behind.
• Evening: return to Becky's friends house, and have a nice evening playing with Jenna and xbox. Becky and friend go check on cats, which are freaking out, but otherwise doing fine.
• Tuesday, Dec 19th: Some work.  The furnace guys show up and confirm my diagnosis of a faulty flame sensor.  Furnace working again.
• Evening: Head to another one of Becky's friends for some nice dinner.
• 8:00pm: I get a call from my realtor, who just got power and offers his huge generator.
• ~9:30pm: Big generator hooked up and running.  Now we can run some lights and other stuff. Additionally, it runs all night on a tank of gas, rather than having to fill every 5 hours.  Also discover cable service is out.  No xbox.
• Wednesday, Dec 20th morning: wake up from a very pleasant and successful night. Fill tank on the generator and go out to get more gas.  Then head into work.
• 1pm: Becky and Jenna join me at work for some lunch.

In somewhat unrelated news, I saw what I believe to be a couple of river otters swimming in the creek yesterday evening.  The reason I think they were otters was they looked like otters, and the tracks I found in the snow look like otter tracks. I'll have to keep my eyes open for them and maybe get some pictures.

It hasn't snowed any more. In fact, yesterday was a clear, beautiful day.  You can check out the photos I uploaded yesterday for all the snowy goodness, as well as some overdue photos since Halloween.  But, the temperature hasn't gone up, so all the snow is still here.  I even went outside, got some snow, and made some snow ice cream, which I haven't had in ages. (It doesn't snow enough in Central Texas to get clean snow)

My smart card reader is broken, so I don't have remote access, which makes it hard to work from home.  I decided to go into work today to try to get another one.  It's supposed to snow more tonight, so I wanted to be ready, and not feel like I need to go in.  The way into work was interesting.  There were still lots of cars in ditches or stuck going up hills, etc.  But, I can't find a card reader, so I'll probably head home soon.  I don't want to risk getting stuck on the way home.  So, I'm going to queue up some work for the rest of the day and head out.

It snowed yesterday morning, and evening, resulting in quite the winter wonderland.  We didn't get as much as Jeff did up in Bellingham, but any snow to us is alot.

Also, last night while we were feeding Jenna, we heard what sounded like firecrackers going off.  Seconds later, the whole house shook with a huge thud.  It took me a few seconds to realize what had happened.  Several large branches had broken off one of the trees on the northeast side of the house, and one of them had hit the roof on the way down.  I believe the only damage was to the gutters, but I'll have to see.  There is still a large piece of the branch on the roof.

The branches don't look very big when they are way up in the tree, but when they get to the ground, they are small trees themselves by our Central Texas standards.

Today is my brother's birthday!  This is the first year in as long as I can remember that I haven't been able to be around close to his birthday.  We've missed he and his wife Sara quite a bit.

Happy birthday, bro.  This next year will be an amazing one for you.  We look forward to seeing you around the holidays.

Today, we are closing on the sale of our house in Austin.  What a relief to have that over with.  She was a good house for many years.  In many ways, we'll always miss that house, but we're excited about the new things that God has planned for us in our new house, which we love so far.

Starting on Halloween (a couple of days shy of 11 months), Jenna passed my criteria for walking on her own.  Becky brought her up for some of the MS-sponsored Halloween fun, and to our surprise was totally capable of walking down the halls of building 42, grabbing candy that people had placed outside their doors.  Evidently, our house was simply too cluttered with the chaos of unpacking for her to be able to demonstrate it fully there.

To add to the hilarity, she was dressed as a monkey.  I've had pictures of this for quite some time, but I haven't uploaded them to Flickr yet.  They are awesome.

So, this weekend, we purchased and installed 3 hardware-mounted baby gates to keep her from getting into too much mischief so that poor Becky doesn't have to case her around all day to keep her from getting into trouble.

I got my internal blog set up yesterday. At my old job, I found having an internal blog was very useful for lots of reasons. Here, due to the size of the company and confidentiality concerns, it may not end up being as useful, and I may have to leverage other resources like Sharepoint to accomplish similar things. For now, other "softies" can catch me at http://blogs/markmil. If you're not on the Microsoft network, don't expect that link to take you anywhere.

We took advantage of the day off and drove up to Bellingham to see Jeff and Bethany.  We started with a delicious lunch.  Jeff grilled some burgers and corn, while I let Jenna crawl around on the lawn, which she seemed to enjoy quite a bit.  The burgers were great, and the corn was so good it didn't need butter.

 While we ate our dessert of ice cream and cookies, we talked about our options for the day and finally decided to head toward Mt. Baker on the Mt. Baker highway.  Due to the distance and our time constraints, we knew we probably wouldn't make it all the way there, but they knew of some cool spots on the way that were a bit closer.

One the way, we decided on our actual destination, some falls near the mountain that they had visited before.  It was spectacular.  The whole area was amazing.  The scale of everything was staggering.  We hiked down some trails to get a better view of the falls.  Becky and I traded off carrying Jenna and the camera so I could carry Jenna down the steep parts, then trade off so I could get some shots.  Some of them turned out really well and really look like postcards.  I got a huge panorama of the waterfall itself (right).  For some reason, I like to leave the jagged edges on there.  I might make a cleaned-up version though since it turned out so well.  I'm pretty sure most of you will want to move here after seeing some of these pictures.

I really wanted to just run wild through the forest and become a feral human.  I found a huge stone in the woods that was turned upright and covered with moss.  I'm pretty sure it had something to do with the plot of Halo 3.  I'm also pretty sure that there were many sasquatches watching us from the woods.  I'm fairly certain that they are hidden in a few of my pictures.

I also experimented with a technique called wiggling which uses 2 shots with different perspectives to provide a semi-3d effect to give you some depth that I don't think is conveyed through the photos.  I think my 2 perspectives are too exaggerated.  It kind of gives me a headache.

On the way out, we visited the ranger station where there was the usual ranger station information and a really big cross-section of an extremely old tree. I don't remember how old it was, but it was old.

So, visit my Labor Day 2006 photoset to see all the pictures. (be sure and click through the various links above as well to see some cool new features of Flickr that allow you to see where pictures were taken. (as well as some other neat links))

Becky, Jenna and I made an impromptu trip to Mt. Rainier yesterday.  We figured we might as well see it up close since today we're driving up to Bellingham to hang out with Jeff and Bethany and swinging out to Mt. Baker.

Simply put, Mt. Rainier is the biggest thing I've ever seen on planet earth.  It is enormous.  It's over 14,000 feet.  Think about that for a minute, that's taller than Pike's Peak, and Seattle is more or less at sea level.

The picture on the left (courtesy wikipedia) is the view of Rainier from the Space Needle in Seattle.  I think it's over 60 miles away from there. It's unbelievably huge.  When it's visible, it dwarfs everything else you can see.

Anyway, since the trip was unplanned, we basically entered in Mt. Rainier into the GPS and followed the directions.  The roads in the National Park were categorized by Becky as "pants-wettingly scary".  Driving next to a sheer cliff with no guardrail is indeed "white knuckle driving".

Despite that, it was wonderful fun.  We got some pretty good pictures, but with me driving, and Becky tending to Jenna, we didn't get as many as I'd like.  I'm sure we'll be back there with friends and family many times, so I wasn't that worried about it.

This is my best picture of the mountain.  It was a pretty hazy day (it wasn't visible at all from Bellevue), so even at close range (still about 10 miles away) I had to do some post-processing to bring out the details.  On the way out of the park, the sun was hitting it and it was even better, but we were in a hurry to get home.  It's interesting that my close-up picture does do it's size justice (the space needle picture above conveys the scale much better), but in person the size really makes you dizzy.  We came around a corner to this view, and Becky and I both just about had a heart attack.

We're about to head up to Bellingham.  I'll try to get some better pictures of Mt. Baker.

Oh yeah... and today is Labor Day, so enjoy this Homestarrunner classic.

Today was quite an exciting day.  First, I got my "alias" changed.  At MS, your alias is more or less your identity.  It's your email address, it's your login, etc.  I wanted to try to get marklio, but, by strict company policy, it's a combination of your first and last name.  Unfortunately, as I've mentioned before [1, 2], Mark Miller is a fairly common name, and there are already a handful employed at MS.  In addition, there are Mark's with other last names that start with M or even Mi.  And Millers with first names starting with M, Ma, and even Mar.  So the valid, un-lame, available combinations are all gone.  I was assigned marmill, but was able to get it changed to markmil, which was the least lame of the available aliases, and I'm reasonably pleased with it, despite the things that get thrown out of whack when it changes.

I also attended some meetings where there were some exciting things announced.  Unfortunately, I can't talk about them. Sorry.

Additionally, everyone is getting excited about Vista.  The latest build is pretty good, and it's cool that our team has a deliverable in there.  There was a party on the athletic fields this afternoon celebrating a big milestone.  It was pretty fun. They were giving away some cool frisbees, but I neglected to get in line for one early, and they were out by the time I went looking for one.  The food was pretty good, but their idea of BBQ chicken was fairly blasphemous.

Finally, I actually did some real work.  Due to vacation, illness, and higher priority focus on my team, there was a backlog of bug fixes under our ownership that needed verification, so I stepped in and ran the "repros" to verify the fixes.  It was cool to see the process and how in-depth it is.  Open Source advocates often use the argument that they have "more eyes" on the code, and therefore more bugs can be found/fixed, resulting in higher quality code.  After being part of both worlds, it is my opinion that it is highly unlikely that there is any sizeable open source project with consistently more "eyes per line of code" across the whole codebase than what is coming out of the CLR right now (and probably many other MS products that I can't speak to with experience).  Quality is an extremely important goal here, and from the metrics I've seen, that goal is being reached.

Oh, I also met some members on the team that I have strange and bizarre connections to.  One guy, upon learning I grew up in central Texas asked if I knew where Belton was.  Turns out, I went to high school with his brother-in-law, and his wife went to high school with my brother Andrew, and was actually good friends with him since they both played tennis.  After some further conversations, it turns out he actually met Andrew a couple of times!  Turns out, there are quite a few Texans on the CLR team.

Needless to say, I'm very excited to be here.

Not to diminish the previous post so immediately, but today is Becky's birthday!  As luck would have it, Becky's brother Andy is moving to Vancouver, BC, which is only a couple of hours away.  And, even more luckily, Becky's dad and Andy are driving through Seattle today on their way to move him in. So, due to several remarkable coincidences colliding with perfect timing (more likely God doing what he does best), for the first time in about 8 years Becky gets to be with some of her family on her birthday, and in Seattle of all places.

So, they are to arrive just after lunch today, and we'll have a pleasant afternoon of visiting and touring and some yummy dinner somewhere.

Here she is trying on a new scarf.  It's a little big.

Happy Birthday Becky!

We made the beautiful drive from Bellevue to Bellingham to visit the Flints yesterday.  The drive was very scenic, although the traffic was pretty bad in several locations due to construction.  We arrived and got the tour of their house, and then preparations for dinner commenced.  Jeff flexed his cooking muscle (see image right) and prepared chicken fried steak, which was absolutely delicious.  I like to think it had something to do with me filling the pan with the perfect amount of oil.  Bethany prepared some yummy vegetables.

During the preparation of dinner, Becky's french horn arrived, which we had shipped to them to get it here as soon as possible.  That worked out perfectly.

Due to the beautiful weather (sunny, about 70 degrees), we were forced to eat outside in their great yard, where blackberries grew in abundance (yes, that is an actual picture of the blackberries we saw, not a stock photo of blackberries.  Great picture, Becky).  If we had known, we probably wouldn't have bought blackberries at the market the other day.

After dinner, we toured some of Bellingham.  We went down to a popular park on the water, and drove around downtown and got out and toured Jeff's church.

All in all, it was a delightful evening.  The trip back was long due to lane closures and construction, but it was worth it.  Thanks Jeff and Bethany.  I leave you with this panoramic view of the backyard. Click it to view the whole set.

Becky, Jenna, and I drove into Seattle again this morning.  This time, we went to the world famous Pike Place Market, perhaps most known for the famous Pike Place Fish Market.  You probably remember it from "Sleepless in Seattle".  It's the place where they throw the fish around.

Anyway, we went there.  It was pretty cool.  There were tons of people there, so it was a little stressful navigating with a stroller through the smaller hallways.  We bought some red snapper to eat this evening.  Should be good.  I didn't catch any pictures of fish in the air because my good camera hasn't arrived yet.  We're using our old one and it's too slow to get stuff like that without alot of preparation.  Becky also got some fresh rasberries and blackberries, the likes of which she has never seen before. (Evidently, they were good).  We also got some yummy cinammon rolls for the ride home. I'm sure we'll go back many times, especially when friends and family come to visit, so I'll try to catch some actual pictures of fish in mid-flight.

Here's an autostitched panoramic view from the top of the parking garage near the market.  I think it turned out pretty well.

This is more or less a test to see how this works.  This is not the first time she's laughed, nor the first time we've caught it on video.  It IS pretty funny though.  Enjoy.

I took several groups of pictures during the move that I've stitched together into panoramas with AutoStitch.  Some of them didn't turn out, others turned out great, and still others are fairly good.  Autostitch is nice because it only takes about 5 seconds of human intervention to make one.

Here's one of the loading process.  The truck was really enormous.  It had our stuff along with several other shipments, and the driver had several more stops to make before he headed to Seattle.  It will be cool to see him again when he brings the stuff that's coming to our temporary place.  He said that would be around Thursday.

Several people have asked about our new place.  It's a very nice furnished apartment.  I made a panorama of the view from the balcony (yes, we're on the second floor).  It's a crazily-wide view, so the edges are distorted.  Don't let that fool you. The trees are super-tall.  When sitting inside and looking out the door, you can only see about half-way up.

The living area is very nice.  It's somewhat similar in layout to the old apartment we had in Austin we we first moved there.  The kitchen is pretty small, but it's nice and open, which makes it feel bigger.  The sliding door there on the left goes out to the balcony.  As you can see, I miss my TV.  We do have a DVD player though.

The "master" bedroom is pretty nice.  It has a nice big window and an attached bathroom.  The closet is also pretty huge.

I'm running out of stuff to say, so Ill just post the rest with a short description.

The guest bedroom.  The crib was supplied for us, which was great.  One less thing to worry about.

This is the main bathroom:

 Here's the utility room:

 I've got more photos uploaded, I just need to go through them and make the non-pano source ones public and tag them.

Well, almost.  By the time you read this I probably will be.  The truck arrived on schedule this morning, but the moving company forgot to send out the loaders (which was odd because the packers were here yesterday).  That was fine because the driver had a chance to go around and tag all the furniture.

Anyway, things are eerie around here.  Nothing but lots of little pieces of garbage everywhere.

I'll get some pics up on Flickr later.  I'm working with relatively limited internet access through my phone.

I've got a hotel room lined up for us tonight, then it's off to the airport late in the morning!  Crazy

The packers came early this morning and packed all our stuff.  I was completely amazed at how many boxes it took to pack up the kitchen.  It pretty much took 1 person dedicated to the kitchen, while 3 others did the rest of the house.  From what they said, it's typical.  The kitchen has to be packed with more padding, so it takes up more room and takes longer.

Anyway, the loaders come tomorrow and load up everything.  That will be even crazier.  The house will pretty much be empty.  Then, we fly out on Thursday about noonish.

I simply don't have room to take my camera on the plane, so it's packed.  I'll try to snap some pictures with one of the lesser cameras though.

I'm getting ready to shut down my PC for the last time here in Austin.  The packers are coming tomorrow morning.  I hope they're not really mad at how unprepared we are.  Anyway, things are getting pretty stressful here at the end.  There's still so much to do and only a couple of days left to do it.  We said goodbye to my brother and his wife this evening, which was pretty sad.  I've never lived more than about an hour from my family my whole life.  Things will be very different with them being that far away.

We did finally find out where we will be living for the next couple of months while we look for a permanent place. Here's a bird's eye view.

We've got a ton of possible houses to look at when we get there.

My buddy Dan just posted a skit we did back in college for a marching band event.  He just kind of threw it out there, so I thought I might provide some background.  I'm sure others may remember this differently.  Feel free to correct me in the comments.

The event was Band Follies, an annual event celebrating the marching season, which gave the band a chance to hang out in a purely social situation.  Each year, band follies is themed, and this year was a toga party.  Another tradition is that whoever wants to can come up with a skit to perform toward the end.  Kappa Kapa Psi and Tau Beta Sigma, the band's service fraternity and sorority (respectively) also each do a skit, primarily, to show the freshmen how "cool" we are so they'll want to join.

I remember the meeting where we (KKPSi) came up with the idea for our skit.  I had only 1 criteria in mind:

• As gory and bloody as possible

We decided to go with a well-known historical event, and simply give our rendition of it.  Since it was a toga party, we thought we'd play on that and do the death of Ceasar.  Jeff Flint, our benevolent drum major, played Ceasar, and Victor Villalobos played the part of Brutus, although his name was Victor in the skit for some reason.  I led the public rebellion against Ceasar. (I'm the one in the red cap)

One of the problems with the skits in the past is that we were too lazy to rehearse or come up with a real script.  So, to combat this, we wrote the beginning and end, then broke up into smaller groups that would each come up with a "fight scene" during the middle of the skit.  Again, the only criteria was to be as gory as possible.

Dave and I were a team, and our gimic was to be a spectacular exploding head.  He would attempt to defeat me, and I would attempt to evade his attacks with ninja-like skills, then, after being horribly wounded in the stomach, I would turn behind him and crush his head with a mighty blow.  Kool-Aid would splatter everywhere, and the audience would have no other choice but to vomit uncontrollably.  Despite Dave's best efforts, the Kool-Aid leaked and made his paper mache head soggy.  In addition, my Kool-Aid er.. "blood" pack was too strong, and I had to burst it myself, which looked more like a horrible bowel hemmorage than anything else.

Anyway, the other guys all had very hilarious fight scenes, which involved everything from fake arms (a la Monty Python) to real cow livers.  The real payoff was Victor's last Scooby-doo inspired line:

...and I would have gotten away with it too, if it weren't for you pesky Romans!

It was really meant for a live audience, but watch it anyway.  Hopefully with this background it might actually be funny to a random person.

Oh yeah, Mark Bauman and Dan Obregon played medics, who would attend to the wounded as an excuse to get them out of the way for the next fight.  They actually had some of the funniest lines in the whole skit.  Too bad the sound wasn't good enough to catch them.  Do either one of you guys have your original script?

I was watching Jenna this afternoon, and she was crawling around and generally having fun.  She crawled over to a little book (Goodnight Gorilla, to be exact), openned it up, and began making noises.  This was nothing new.  She does this often, and we think she is pretending to read it.  What I was most amazed by was that she began making sounds like E-I-E-I.  This of course is familiar.  So, I grabbed her Old MacDonald book, which was nearby, and began reading it.  Lo and behold, Everytime I read, "Old MacDonald had a farm...", she would respond with E-I-E-I-E-I.  I was completely amazed.

I took me a while to realize that I ought to be videoing it.  By the time I started rolling, she was less interested, but I did get it a few times. If I get a chance this evening, I'll get it encoded and get a clip up here.

Today is the birthday of my good friend Dave Barnes.  Dave and I played trombone together at Baylor.  He and his wife Jen moved here to Austin a few years after we did.  Them being here made our decision to move a difficult one.  I'll certainly miss Dave, but thanks to XBox Live, we can still play.

Here he is leaping over the creek on the frisbee golf course near my house.  He made it...this time.

Well, today I am officially unemployed.  I just made my last commute home from Freescale Semiconductor.  I'll really miss my old team and the fun times we've had.

Now that I'm unemployed, Becky and I are free to follow our dream of moving to Washington state in hopes of finding the elusive sasquatch or "wood ape".  That's right, I'm not going to work for Microsoft after all.

My plan is to drive through the forest roads at high speed, hoping to catch the beast unawares and hit it with my huge, 80's style station wagon.  Thinking it dead, I'll strap it to the roof and drive home, only to have it wake up and scare us.  In my panic, I'll brake abruptly, sending the hairy bigfoot flying through the air.

After some misadventures, my family and I will grow to love the gentle giant, and seek to return him to his home, lest he be poached by his arch-nemesis, Jacques LaFleur.  In doing so, we'll realize that if we lived more like these gentle sasquatches, in harmony with nature, that we'd all be better off.

I'm going through the piles and piles of electronics I've accumulated over the years trying to decide what goes and what stays.  I've got a fair number of items that I don't think deserve to be trashed, but I don't want to cart them halfway across the country (literally). So, I've decided to list a few items of interest in hopes that they will find a good home.

The rules are, items will go to whomever I feel like, mostly a function of convenience for me.  If there is alot of demand for an item, money will grease the wheels for you :). If there are specific items you want from the "bundles", let me know and I'll think about it. Here are the items:

• Playstation 2 "bundle".  Includes:
  • console (w/network adapter)
  • 4 controllers (with a multitap)
  • logitech force-feedback steering wheel
  • Handful of games including Amplitude, Gran Turismo 3, Burnout 3 and Socom II
  • All normal cables plus component and s-video
• GameCube Bundle:
  • Console (platinum) (w/network adapter)
  • 1 controller (2 if I can find the other one)
  • 2 sets of Bongos
  • handful of games including Donkey Konga, Zelda (several versions), and Mario Kart (if I can find it)
• Robosapien
• 2 10-inch subs w/amp all installed in box.
• Several PC cases of various age.  One is a very nice black Antec desktop, which I replaced only a few months ago because I needed a tower for my new desk.
• A couple of old CRT monitors.  They technically work, but are old. One is huge (19" I think) one is more like 17".
• Large RC car.  Electric.  Great fun.  with good charger.  A couple of cycles and the battery should be fine.
• Tivo Series 1 - The hard drive is kaput, but there are numerous hacks available to replace it and do other cool things to it.
• Creative Nomad Jukebox 3 - This is an old iPod-like device. It technically still works, but it pretty much sucks. I'd love to just take it apart and hack on it, but I haven't gotten around to it.  It's got some interesting  features. Digital optical input, surround sound support, etc.
• Lots of really old stuff like modems, video cards, etc and stuff that I'm pretty sure no one wants.

I'll add more as I come across it.

Today is our 7th anniversary.  This year, our anniversary is during a particularly hectic time as we prepare to move to Washington.  Becky's been a real trooper, putting up with all the work I'm having to do to get things ready for the move.  Things are coming together though.  The haze is clearing and we can start to see the light at the end of the tunnel.  It's so much fun to have such an adventure with such a good friend.

Anyway, my parents came up on Saturday and helped us with some projects to get the house ready to sell.  That evening, they watched Jenna while Becky and I went to see the latest installment of the Pirates of the Caribbean.  I thoroughly enjoyed it.  I was a little confused about a few plot points, like why was Jack looking for the key before he found out that Davey Jones was after him?  Maybe it was part of the whole compass counter-story, and him not realizing why or what he wanted. Personally, I think they rearranged the scenes so they could use the openning scene as the openning rather than where it originally was in the story.  I also hadn't realized that it would be such a segue to the next movie.  Unlike me, Becky saw the ending coming a mile away, which is opposite of the way it usually is.

I'm also glad we had watched the original on TV the other day rather than our DVD.  The TV version had the extra "monkey scene" at the end.  Much of the second movie wouldn't have made sense if I hadn't seen that extra scene.  I wonder when they added it.

Things have been uber-crazy around here the last month or so. The quality and quantity of my posts had been seriously lacking, and there have been tons of things to post about.  Jenna's crawling everywhere, standing up and walking while holding stuff, and starring in a broadway musical (OK 2 out of 3 isn't bad).

Anyway, I've neglected my readers, and I apologize for that. Hopefully that will change soon. I thought I would come up for air for a moment to announce that I have accepted a position at Microsoft.  Becky, Jenna and I will be relocating to Redmond, WA (near Seattle) sometime in August (wow, that's soon isn't it).

I will really miss my current team, our local friends, and church; but Becky and I are super-excited about this new opportunity.  I'll post some more details when I get a chance (and after I learn for sure what I'm allowed to talk about), but for now I can tell you I'll be working on the Common Language Runtime team.

Becky and I are vacationing with her family up in Cape Cod.  We've been up here since Friday evening, but I haven't blogged about it because the trip got off to a horrible start.  I may tell the whole story some other time, but right now, I just wanted to get everyone up to speed.  It's been raining since we got here, but that's fine with me.  We're just hangin out.

Here's a local.live.com collection of places of interest from the vacation.  I'll keep updating it as things happen.  Be sure to check out the bird's eye view images of the house and such.

Becky sent me an IM earlier today to let me know that my XBox360 just arrived.  I had to send it in for repairs after it died a week or so ago.  The repair process was pretty simple.  They sent me an empty box.  I took off all the accessories and put the console in the box and dropped it off at the UPS store.  And now it's back! I'm hoping that there aren't any more problems.  I can't wait to download the new system update and try out 1080i DVD playback with my new VGA cable!

If it does everything it says it does, the update fixes every single complaint I had about the dashboard and system software. yippee.

[UPDATE] The VGA settings do not have a 1080i/p compatible setting, so no 1080i DVD playback for me.  Looks like the VGA cable is useless for me.  Back to Best Buy it goes! Here's hoping for DVI support.

I had a conference call with some people in one of our facilities in China.  My manager is currently over there and I was going to run a presentation and demo from over here.  I VPN'ed in from home and waited for the call to begin.  Evidently, the conference room they were in had a broken telephone, so they were unable to call in.  After a while of trying to fix it, my manager said he didn't think they were going to get it working and did I have any ideas.  We were already communicating via Google Talk, so I just hit the "call" button.  A couple of rings later, we had a perfectly clear and relatively delay-free voice communication channel.

I was running the demo via netmeeting, but the netmeeting voice chat is horrible quality and there is a sizeable delay.  I was able to give the whole presentation and demo via Google Talk.  Well, until someone kicked the network cable on the other end and disconnected the whole thing.

Scott Hanselman pointed out a service that I am sure to get tons of use out of in the next few months.  ThanksNo.com is a polite-as-possible way to remind your friends and family that you really don't want to get all those forwarded emails, jokes, or other "non-personal" emails from them.  It does a good job of pointing out why you don't want them, which is often hard to explain.  Visit for yourself to see what I mean.  You pretty much reply to the email with a short message and the link, and hopefully the flood of "non-personal" email from people you know will cease.

This has been a huge problem for me.  I get all kinds of emails from friends and family with dozens of people copied, and with very little, if any, value.  In the past, I've dealt with them by just silently archiving them for fear that any email explaining that I didn't want that kind of email would be misinterpreted.  (Actually, maybe this blog post will do the trick.)

<Begin SoapBox>

Now all we need is a similar service for what I refer to as "corporate spam".  Why bother having any kind of intranet at all if you're going to send out 3 emails a day to every employee full of useless or redundant information?  I can understand getting the information by default, but at least let me opt-out of all but the most important emails.

And another thing.  What's will marking every email as "high importance"?  It has lost all meaning when you get an email at work marked urgent, you open it up quickly to find out what action you need to set aside all of your important work for only to find out that there is a bake sale next week.

<End Soapbox>

During the last PDC, I drooled over the announcements regarding C# 3 and LINQ.  Now we are one step closer. Yesterday, they released a new preview of those features that bind against the current version of the framework.

Skeptical language junkies* should take a gander at Don Box's latest post that attempts to explain what the big deal is. I agree with some of the people saying that the syntax really gets in the way (and I feel that way even more after spending alot of time in Ruby lately).  They need to add a language feature that indicates whether you want the lambda or the expression, then you can fall back on type inference to keep the typing to a minimum.

Overall, I couldn't be more giddy about the way integrated query works, and being able to get your hands dirty with it now is really awesome.  We're already working with data in this way in our APIs at work, so I've been able to experiment with the language and library features directly with some of our data and it's an absolute dream.  They should not wait for the next version of the framework to give us a go-live license for this.

Now, this kind of thinking needs to be applied to the web stack and MS could have a compelling alternative to Rails.

* That is, language junkies who are skeptical, not junkies of skeptical languages.

I've updated my blog's tagline (at least temporarily) to celebrate.  Halo 3 was just officially announced.  Hop over to bungie.net and check out the trailer, or download it from the XBox Live marketplace.

I simply can't wait.  I'm going to pour all my energy into building a time machine so I can travel ahead to 2007.

I figured out how to draw historical track log data from my tracking app onto the Virtual Earth control.  It's a pretty early implementation, but it works really well.  I'm generating transparent PNG images on the fly and using them as the content of a well-placed pushpin. Here's a screenshot:

Don't be confused.  If you've played with the VE API, you may think I'm creating a pushpin for each datapoint.  I'm not. I'm creating one image and overlaying it on the map.

Once you figure out how to take the latitude/longitude to pixel translation to the server-side, it's fairly straightforward.  The hardest part about it is geting transparent PNG images to render properly in IE.  Hilariously, my workaround currently breaks the functionality in anything other than IE.  Just stupid.

Anyway, now I have to resolve a few little issues as well as "tile" my overlays much like the virtual earth image tiles.  That should fix some of my performance problems.

[UPDATE] OOPS! Something I changed last night broke the tracker position.  Not sure where the problem is, but rest assured that I AM at work today, and not still at home.

I developed some spiffy new features last night for my GPS tracking app around MySQL's sweet spatial data extensions.  When I finished late last night, I was going to deploy the app to my hosting provider and discovered that they are currently running an older version of MySQL that does not include these features. Doh!

Anyway, I've gotten alot of cool ideas from friends for what I should do with the data.  I have in mind a service with a scope much broader than tracking my position.  More on that when I get some more of it working and get it on a real server.

I've been loving my new phone.  In an effort to fully exploit and justify my unlimited data plan, I've been dreaming up applications for it.  My latest one is something I've always wanted to do.

I hooked up a bluetooth GPS and capture my position.  Every 10 seconds or so, I send the logged data to a server.  I then have a spiffy Rails app set up to display my current location on a Virtual Earth map.  The page uses AJAX to poll the server every 10 seconds or so to update my position on the map.

I've got lots of ideas for how to mine and visualize the data, as well as provide nifty tools for my friends and family to track my location, as well as hooking the data up to my Flickr uploader (rewritten now in just about 20 lines of Ruby code) to automatically geo-tag my photos when I upload them.  I've got lots of cool things I plan to do with it while we're on vacation this summer.

I'll have live demos for the public available soon.  Some of my friends have been playing with it already as I debug it. For everyone else, here's a shot:

If you're a friend of mine and want to play with the live version, lemme know and I'll shoot you the temporary link.  Most of the time, it's pretty boring because I'm at work, but hold on to you hat when I start going somewhere.

It's my buddy Peter's birthday today.  He's finally as old as me again.  Here he is holding Jenna for the first time, which I'm glad he got to do.

Happy Birthday, man.

My old phone was giving me tons of trouble.  Dropping calls regardless of the signal strength and other really annoying things.  Unfortunately, we were part of the old AT&T Wireless group that never got completely absorbed by Cingular, so getting a new phone meant switching plans and providers and meant getting a new phone for Becky too.

Historically, I've done this kind of thing online, and invariably ended up with some problem that made me waste alot of time on the phone with customer support.  So, I did my research and just went to a Cingular store.  I walked out with my new phones.  I was very pleased with how it went.  I stuck with Cingular because most of my friends and family have Cingluar, which gives us unlimited talk time with them, so the plan minutes really don't mean anything.

I got a RAZR for Becky, and for the first time, I own a non-Motorola phone.  It's the Cingular 8125.  HTC makes it and Cingular rebrands it.  After having it a few days, it is the perfect phone for me.  It's a Microsoft Mobile "Smartphone".  It's basically a fancy PDA and a phone merged together.  I've owned countless PDAs in the past, and I finally had to promise myself that I wouldn't buy another one.  After a few months or so, I would stop using it because it was "one more thing" to carry.  And if I wasn't carrying it, I wasn't using it.

Smartphones are nothing new, but what's special about this one is the number of ways for it to connect.  It has:

• GSM/GPRS/Edge - The mobile phone data protocols
• Bluetooth
• IR - I actually used this the other day
• USB
• The big one.... WiFi!

Also, in addition to the normal draw on the screen entry methods, It's got a slide out keyboard.  So far, I've used the stylus mostly, but I can see falling back to the keyboard to write stuff longer than a textbox.

It also has a 1.3MPixel digital camera that acts like a camera when it's in camera mode.  So, it'll be easy to snap shots or videos of Jenna when it would take to long to get out the "real" camera.

It also has a mini-SD slot so I can add capacity.  I'd rather it have compact flash since I already have some big sticks of it for my real camera, but it'll have to do.

The only thing it's missing is built-in GPS. However, there appears to be a big market for Bluetooth GPS units, which would be fantastic since often you need the receiver in a different place than the map program.

So, it's my phone, so I'll carry it by default, and it's a wicked PDA, so I'll use that.  And the best part is that cost-wise, I've paid more for cellphones without most of these features

I was on the way back to work from lunch, and I saw a truck with a trailer full of large boxes.  I could not tell what the contents were, but on each box was the company's slogan in big letters....

If anyone deserves it, you do

I think that is a hilarious slogan.  What's in those boxes?  Every possibility made me chuckle.  Rat poison, suppositories, hand grenades, spoiled food, etc.  Is it a sarcastic, humorous slogan, or are they simply playing to people's vanity?

After some Googling, I determined it was furniture from Berkline furniture, which was kind of disappointing.

Between work, the baby, and 1000 other things, I haven't had time for blogging.  Then there is the strange phenomenon that occurs when your thoughts get backlogged and you don't want to blog about anything until you've gotten everything in order because you don't want to leave out anything.  So, I figure what better way to get back into it than to post a completely trivial review of a video game.

The new Ghost Recon (or GRAW for short) came out recently for the XBox360, and my friends and I were fairly excited.  Even though we've got 360's, we've been playing Halo 2 on them.  GRAW seemed to be the game that would let us have our online fun on a real next-gen game.  Now that I've played it a while, I've developed some opinions about it.

The single-player campaign mode is pretty fun.  I don't really like games where I have to command other non-player characters.  I don't really mind if they wanna come help me, and I can suggest things for them to do.  This game appears to suit my tastes in that category pretty well.  The other guys will follow me around and shoot at stuff and generally do what I'd like them to do.  The only thing that is stupid is the medic command.  When one of your guys is hurt, they fall down and you have the option to command one of the other guys to help patch them up. Why do I have to do that?  Why can't they figure that out on their own?  In addition, why can't they help you when you're the one that's hurt?  Other than that, the weapons, the sense of urgency (it's a pretty good special forces simulator), the missions, and the visuals lead to a very nice game.

That said, I don't really like playing games by myself, so multiplayer is weighted very heavily on my scale of game goodness.  First off, the multiplayer is a very different game than the single player.  Several key elements of the game are missing (taking cover, vehical control, etc).  But the drone, and the cross-com cameras are still available, which enable some very cool in-game communication. It really feels like you are your friends are moving steathily through the jungle taking out the bad guys with your high-tech, but realistic arsenal.

The only problem is that there is no "party system".  This is a common problem with online multiplayer games on my opinion, and it's just stupid.  Halo 2 does this wonderfully, and it's a very old game by now.  Halo 2 made it stupid simple to get into a party with your friends and then jump into games with other random people.  In Ghost Recon (and just about every other game I've played), someone has to start up a game lobby.  Then, you can join it.  Then, once all your friends are in the lobby, you sit there and pray that some other people will join.  What usually happens is you start a short game to play while you're waiting, and you end up playing a stupid game for 30 minutes waiting for enough people to show up for the other team so you can play a real game.  The problem is that the people you really want to play against (parties of about 4 people looking for other parties of 4 people) are doing the same thing you are doing because the alternative is so frustrating.  The alternative, is to pick someone to be the game finder.  When they find a game, they join it, send out invites and beg the host not to start until all your friends can get in.  Chances are they won't wait, or the host gets tired of waiting and ends the lobby and everyone is out in the dark looking for each other again (remember there is no multi-person chat in the 360 dashboard).  Or you end up playing lobby tag with your friends because more than one person is actively looking for a game for the group to play in.

If people on your friends list are already in a game, joining is a hassle.  You can respond to an invite, or choose "join session" from the XBox360 guide blade, then you get a stupid dialog box that tells you you've decided to join a game, and it only has one option...OK.  Whoever let that brilliant piece of UI into the released game should be given several lashes.  Then, you are forced to go through another login type procedure and finally end up in the lobby of the game (if it still exists).  If it does exist, you have to sit there and wait in the lobby until the game is over before you can interact with anyone in the game.  Ghost Recon game types are typically very long (~30 minutes), so you just have to sit there.  At least let me play a mini-game, or be an in-game observer or something.

In any case, if the host leaves the game for any reason, everyone is booted from the game and you have to hook up all over again.  These are all problems that have great solutions already.  All you need to do is fire up Halo 2 to see how it should be done.

Luckily, Ghost Recon has a rich online co-op mode, which allows you and your friends to team up against the A.I. in campaign style missions or other elimination, or objective games.  As I said before, it's fairly easy to get your friends into a game. This redeems the game enough to make it a blast to play.

So, will I have fun playing it...Absolutely

Will I be annoyed every time I play it...Absolutely.

Well, my new TV arrived yesterday afternoon, so after work, church, and getting Jenna to sleep, I finally got to hook it up.  The first thing I did was fire up the XBox360.  The dashboard just about knocked me across the room.  It is breathtakingly beautiful.  I fired up Halo 2 to check for video lag (for which I had to send my previous set back if you recall).  I was pleased to find minimal lag "out of the box".  A quick jaunt through the menus revealed "game mode", which eliminated the lag altogether (or at least to a point indistiguishable from my previous lag-free CRT set).

So I'm really looking forward to the HD Olympics coverage this year.  I hope it doesn't suck like it did 2 years ago for the summer games.  We'll see.

All said and done, I couldn't be more pleased.  We see what little annoyances I can find in a week.  I'm pretty picky.

(pictures coming)

I've had the itch for a new TV for a while now.  Mine is what I would call a "first-gen" HD set.  It's a 40" rear-projection CRT capable of 1080i scan rates.  As a CRT, it is subject to all the CRT problems:

• Non-linear geometry problems across all 3 tubes - This could be summarized with "convergence issues", but causes lots of different visible anomalies.
• Focus issues across three projectors
• Blue gun "bleed"
• "hot spots" of different color temperature across the screen.
• Heavy as heck
• etc.

Beyond that, as a first-gen set, it has some problems like not dealing with different aspect ratios cleanly, no digital inputs, etc.  In addition, it's getting old and is having some electronic problems.

Back in October, I ordered one of the new 1080p Sampsung DLP sets.  It was beautiful, but I sent it back for several reasons:

• The DLP rainbow effect was very bothersome to me
• The "video lag" made playing Halo 2 virtually impossible

I was very dissapointed to send it back, and I've been scared to get another one, for fear of the same dissapointments.  But I think I'm finally ready to get another one.  It's Sony's new 1080p SXRD set. It's based on Sony's implementation of LCOS (Liquid Crystal on Semiconductor).  It's a three-chip solution (separate chips for red, green, and blue), so it won't be able to do ClearType, and will have some convergence to deal with, but at that resolution, ClearType won't be necessary and any convergence problems will be linear and shouldn't be a big deal.  In addition, I have read lots of reviews that indicate there is no video lag with the xbox360.  I'd like to get personal experience with this, so I may cart my 360 to a store and try it out myself.

Anyone have any experience with Sony's SXRD sets?  Any advice?  I think the only thing I don't like about it is those crazy speakers sticking out the side.  All my audio runs through my sound system, so they'll just be there taking up space.

Becky's been starting to teach lessons again.  This time in the evenings so that I can watch Jenna.  It's been difficult for me to be "on display" for her students and sometimes their parents.  So, I've been experimenting with different things to try while she's teaching.  Yesterday, Andrew was able to come by after his tennis tournament in Georgetown, so we decided to take Jenna out on the town.

We took her to Fry's first, where I loaded her up in the Baby Bjorn, and we walked the isles looking at all varieties of wonderful things.  She did very well.  In fact, she slept some.  She loves that thing.  When all else fails, I know I can settle her down in the "bjorn".  She did so well that it didn't matter that we hadn't brought the diaper bag or ANYTHING except for the bjorn.

On the way home, we swung by Pei Wei and picked up some dinner for ourselves and Becky.  Yummy.  Hopefully there will be many more trips to Frys and Pei Wei in our future.

Back the the days of .NET 1.1, you'd use a Hashtable to store values with a fast lookup using a key.  Hashtable used a single array of "buckets", which stored the key, value, and a collision index.  The index to the the bucket array is a transform of the hashcode of the key (unless there's a collision).  Long story short, there was no stable ordering to the values in a Hashtable (technically, the order is super-important to the algorithm, but it's not useful on the outside).

Fast-forward to 2.0, we have the Generic Dictionary.  It's algorithm is quite a bit different.  It has an array of Entry<Key, Value>, a private nested class similar to bucket in the Hashtable.  But, the "bucket" data is stored in a separate array of int, which holds the index into the Entry array for that hash.  When you add something to a Dictionary, it is simply added to the Entry array, and the bucket array is the one that's updated and possibly re-ordered.  Long story short, there IS meaning to the order you get from a generic Dictionary (using the enumerator).  It's the order you added them.  This subtle change adds alot of value to Dictionary in my opinion.

It was just a very interesting realization to me, and I thought someone else might find it useful.

I recently got mail at my domain working properly, and as a result, I've changed my main email address.  Of course, I'd like to get everything converted over.  One thing that's tied to my email address is my MS passport, which of course runs everything from my MSDN subscription to MSN Messenger to my XBox live account (and very well I might add).  Fortunately, you can change your email address from www.passport.com.  I had 2 issues when doing so.

First, I had tried out the windows live custom domains beta, which hooked my domain up with hotmail addresses.  It had some issues, so I had cancelled my service.  But, when I tried changing my email address, it said marklio.com was reserved and I couldn't use it.  Luckily, a few emails to passport and custom domains support cleared that up.

The second problem involves MSN Messenger. All passports have a unique ID underneath that is your actual "ID", even though you don't really see it anywhere.  This allows you to change the email address without changing "identities".  Most things migrated seamlessly (XBox360, etc).  And signing into messenger gave me my contacts list.  The problem was that none of my contacts were ever online.  As it turns out, the entries in the contacts list ARE tied to email addresses instead of the unique IDs, so everyone on my list has my old address in their list.

Booo.  So, if I'm on your MSN messenger contact list, please re-add me with my new email address.  It's mark at this domain (marklio.com).

Yes, the rumors are true.  Today is my birthday, and I am 30.

I know alot of people who got really depressed and overwhelmed when they turned 30.  I wasn't sure how I'd feel, but I can say now that I don't fell any different. That may have to do with Jenna being born last month.  That was such a huge change that 30 isn't that big of a deal.

I've gotten a monstrous barrage of silly e-Cards over the past few days... all from my dad.  Thanks.  And thanks to everyone else who has wished me well over the past few days.

No, I'm not talking about a BBS, although they are certainly obsolete as well. I'm talking about physical bulletin boards. I don't know about you, but where I work, there are tons of bulletin boards.  They just kind of blend into the walls.  Many have not been updated in years...YEARS!  For instance, the one closest to my cube has only a double-length sheet of paper on it with the following heading:

Employee Bulletin Board Ads

Sept 1, 2001

Whoa! 2001! As I walked around today, I looked at other boards and there was not a single one that had been updated in the last year.  This leads me to believe that bulletin boards are not only obsolete, they are dead.  Has anyone seen a working one anywhere?  I think the only place that might still see one is in a school.

As I mentioned earlier, I've been playing with WF.  When debugging in Visual Studio, a program running a workflow pretty much uses 99% of CPU the whole time.  I thought that was pretty scary, especially since I had alot of Delay activities in my workflow.  Well, not to worry, running the .EXE outside of devenv gives you what you expect, a very well-behaved program.

I suspect it has to do with the sweet debugging stuff that's built into the workflow designer surface.  You can add breakpoints to activities.  It's pretty cool, despite crashing on a regular basis.  Hopefully, they'll fix this before RTM.

Today is my mom's birthday.  She got the short end of the stick having her birthday so close to Christmas.  This is her first birthday as a grandmother, a role that she has taken with much vigor. She was in town here yesterday watching Jenna while Becky was out, but I didn't get to see her since I was at work.  Hopefully, we can see her this weekend and have some birthday festivities.

As usual, I'm not including a picture for her, for fear of some kind of demented payback since she doesn't like pictures.

Despite my excitement, I managed to get some pictures of the out of box experience opening up the XBox 360 premium packaging.  I've got the photoset up on Flickr.  It was very well organized and easy to get into and get set up.  Once thing I thought was interesting was that the hard drive was pre-installed.

The AV cables have both component and composite connections for video, as well as analog stereo connections and an optical audio jack.  I've seen several people miss the HD/SD switch on the cable itself, which is nice when you've got the dashboard set up for 1080i, but you've taken it to grandma's who has a TV from the 40's.

I was pleased that I did not have to supply batteries for the remote or the controller.  And, when I picked up a second controller, it also came with the necessary AA's.  That's a nice touch.

Perhaps my only qualm with the hardware itself (which I should probably add to my review), is that the power supply is external, and it is enormous!  Seriously, it's really big.  And it has a large orange LED on it that gives off an eerie glow in the dark.  But, I had forgotten about it until I uploaded the pictures, so it must not be that bad.

The two main High Definition standards are 720p and 1080i.  Since there is plenty of information on the 2, I will not go into detail on them individually.  What there isn't alot of is objective, well-reasoned explanations of which one is better.  Mostly, this is because it is not a simple topic, and the winner depends largely on the context of the question.  Another reason this is so hotly debated is that people spend alot of money on HDTV's and that causes people to become zealots of whatever particular technology they've embraced. I'll try to compare the two within each of the important contexts, without personal bias.

Let's start with the fundamental question.  From a HDTV technology perspective, which is better?  The answer is, they are the same.  Before you leave a comment on how stupid I am, keep reading.  Fundamentally, we're talking about how much data can be displayed at a time.  For TV, that is limited far more by transmission bandwidth than anything else.  To maintain that bandwidth, the signal is compressed in a lossy fashion (see update below). In either format, you're going to get roughly the same "picture quality" watching TV.

Now, you're saying "shut-up, idiot.  One has got to be better.  Why won't my TV do 720p (or 1080i) if they are the same?". This is where the argument gets interesting.  The signal formats were created for "analog" TV technology, namely CRTs.  For CRTs, it's all about frequency.  (How many lines can you draw per second) 720p has more lines per second.  The problem is, you're still bandwidth limited, whatever that limit may be. Horizontal "resolution" comes down to bandwidth.  Any increase in bandwidth basically gives you more capacity for horizontal resolution, so again the two are the same.  The problem is, many HD sets are based on technologies with a "native resolution", meaning the TV is locked in to a certain resolution.  In these cases, the interlacing trick used by 1080i to gain temporal resolution at the cost of spatial resolution is useless.  [Added:] Many CRT-based HD sets cannot do 720p because it requires a higher horizontal refresh rate and the flyback circuit capable of 1080i is not capable of that speed (in short, you got screwed (myself included) to increase their profit margin). 1080i is refresh frequency comparable to 540p (if it existed as a standard).

So, the result is that most HD sets have a native resolution at (or near) 720p.  So, for those sets, a 720p signal matches the native resolution of the set and "looks" better.  There's alot of hype around 1080p sets, capable of displaying, you guessed it, a 1080p signal, which only really exists as the output of a PC at 1920x1080, which brings me to my next point.

Since basically all HD content is stored digitally, we're not just looking at lines of resolution, we've got frame sizes.  So a 720p frame is 1280x720, and you get 2 per second.  That's 1,843,200 pixels per second.  A 1080i frame is 1920x1080, but you only get 1 per second. That's 2,073,600 pixels per second.  So, compression and bandwidth aside, dealing with digital signal sources, you're getting more data (in the form of pixels per second) with 1080i than you are from 720p.  If that's the definition of better, then 1080i is better.

But, as I mentioned before for fixed resolution TV technology (anything but CRT), it takes a 1080p set to show 1080i in all it's glory.  Otherwise, 720p will probably look better due to the down-conversion resampling. Clear as mud, eh?  Well, I hope this clears it up for at least one person. [Added:] A signal will almost always look better in its native form.  Whenever there is a resampling step in up/down converting, you're going to have some degradation due to aliasing.

[Added:] I owned a 1080p DLP set for a few short days, and it was by far the prettiest thing I've seen.  it displayed both 1080i and 720p signals beautifully.  I sent it back, though.  All the upconverting in the video pipeline introduced a noticable delay that made playing video games very frustrating. :)

[UPDATE:] I had a comment asking about the lossy compression applied to video.  I'm referring to the digital compression that the video signal undergoes as part of the ATSC standard.  It uses MPEG2 compression (basically the same used for DVDs) to reduce the digital bandwidth (and therefore the analog bandwidth) that the video signal takes up so it fits in the "channel" (6MHz wide if I remember correctly).  This particular compression degrades picture quality (the amount can be controlled).  It is both a spatial and temporal compression, and gives very dramatic compression ratios.  Cable companies have more bandwidth to work with, but they usually pack the crap in as tight as they can rather than giving us better quality...jerks.

Note, there is also some "analog" compression going on as well to squeeze the ~20Mbit/sec digital signal into the 6Mhz channel.  The ATSC standard uses an 8-bit "vestigial side band" modulation (8VSB), while cable companies use a form of Quadrature Amplitude Modulation (64-QAM).  Both are beyond the scope of this article and neither of these come into play in picture quality as they are lossless forms of compression.

If you haven't guessed, I did a research paper on HDTV back in college.

[Yet another UPDATE:]  Want some hands-on proof?  Go download the 720p (146MB) and 1080i (211MB) versions of the King Kong movie trailer from Apple's site.  Compare the file sizes and then open them both, and you decide which one shows you more "data" (my definition of "better").

Did I mention that I got my hands on a 360?  I lucked out and got one at a very decent price from eBay.  Due the the last big shipment, eBay was/is pretty saturated and the prices have gone way down.  Anyway, I've had the 360 for almost a week, which I think is enough time to give it a thorough run-through and review it.  Overall, I would say it is "wicked awesome".  To back that up, I will give the list of stand-outs and disappointments:

Stand-outs (things I thought were great):

• HD - Many have already called the 360 the "killer app" for HD.  I would agree. There are lots of people getting HD sets and then watching SD, or ED (enhanced definition (480p)) on them and thinking that's as good as it gets.  Let me tell you, just firing up the dashboard in 1080i is a sight to behold.  Call of Duty looks just incredible.
• Connectedness - You can connect to the internet out of the box and download arcade games, movie trailers, game demos, and lots of other cool stuff like themes and such.  Viewing movie trailers in HD is pretty fantastic. It was incredibly easy to migrate my live account.  The new gamercard stuff with reputation, achievements, gamerscore, etc is sweet.  They've definitely been able to build upon the experience they got from XBox Live, and Sony will have a hard time matching the experience, having never seemed to "get" the online experience on the PS2.
• The Dashboard - This has received quite a bit of thought.  It's actually a useful thing now.  You can actually do stuff from here now.  Your friends list is always at your fingertips, you can play your music, either ripped from a CD, or on your PC, or iPod (the iPod support is very nice).  The arcade rocks.  Geometry Wars is definitely worth the ~8 buck download.   The marketplace is interesting, and I think we'll start seeing lots of cool stuff there soon.  Being able to jump into the dashboard at the touch of a button is great.  Built in voice chat also rocks, and is great for organizing a foray into Halo with your friends.
• Backwards Compatibility - Interestingly enough, I don't own any 360 games yet.  Halo 2 runs beautifully in 1080i thanks to the wonderfully implemented backwards compatibility.  I think this is more impressive to someone who knows the technical details of what's going on under the covers. (running code compiled for an entirely different architecture in a virtually transparent way)  The fact that the compatibility list is still growing because they can continue to update it to handle more and more games is also fantastic.
• Controls - The controllers are fantastic.  They are an improvement over the already wonderful "S" controller for the XBox.  Wireless connectivity is the icing on the cake.  USB connections for wired controllers (and MP3 players and who knows what else) was an excellent choice over a proprietary connection.  Being able to turn the console on and off from the controller is awesome.  The optional USB charge kit for the wireless controller is pretty cool as well and has a very long cord if you're low on batteries.
• Notifications - You get cool notifications at pretty much any time (with the exception of Backwards Compat mode) to let you know when friends jump online, or when you get an invite, etc.  I assume this is "shell" type functionality now rather than being part of the game code.  That gives everything a nice, unified feel.

Disappointments:

• DVD playback - I was hoping to retire my DVD player and use the 360 for playback.  Sadly, that will not happen.  There doesn't appear to be any DTS capability.  Also, it would not play the Dolby Digital track on one DVD I put in and just gave me Dolby Pro-Logic decoding from the stereo track.  There is no aspect ratio zooming to correct non-anamorphic or 4x3 DVDs.  I does play at 480p, but I was hoping it would up-convert to 1080i (I've got a rear-projection CRT and I only wanted to worry about geometry/convergence for a single mode).  Now, there may be settings to change these things, but I could not find them.  I would gladly retract this if someone can prove me wrong.  I supposed they could also update the software in the future.
• The headset - The headset that came with mine did not work well.  There is tons of static whenever the wire moves. I think it is a defect since my friend's seems to work OK.  I'll have to take it apart to see if there is a bad connection somewhere.  Luckily, my old headset (as well as any other "cell phone style" headset) works great, but without built-in volume and mute.  Speaking of mute, it is now a switch (instead of a button with an indicator light).  It is much harder to see you are muted when you're in the heat of battle.  Beyond that, they have "built-in" the voice support to the controller, rather than making it a separate module.  This is a good thing, but there were some things about the "old way" I really liked.  The old way, I could remove the voice module and then voices would play through the main speakers.  My friends and I used this in Halo to indicate that we were "away" (the voice icon changes) but would be back (so we could do things like get a drink or visit the restroom).  Now, maybe with wireless controllers, this isn't necessary since I can technically keep the headset on.  I haven't fully explored the possibilities with wireless.
• Video playback - It appears that you have to have a Media Center PC in order to watch your own videos.  That stinks.  What about my friends that have Macs? What's so different about video? I can view my own photos and listen to my own music.  Perhaps they simply don't want to deal with the codec issue.  I may be wrong about that too, but I couldn't get it to work.  I guess I'll have to turn one of my PC's into a media center. Scott says it works great.
• Dashboard downloads - You don't seem to be able to do other stuff while you're downloading stuff in the dashboard.  HD movie trailers take a while (why don't they buffer and stream?) and you're just sitting there watching a progress bar while they download.  That seems pretty silly to me.  When it's done, you get a neat little "done downloading Xxxxx" notification. "Duh, of course it's done. I can't go do anything else but sit here and watch it download".

Overall, it totally rocks.  Go get one if you can find it.  I'll probably pick up this Logitech remote with some Christmas gift cards.

A few weeks ago, the right rear window of our '95 Nissan Maxima has been broken.  Normally, on a Nissan, power window problems are the notorious regulators.  In my case, the motor and the electronics were all working, it was a mechanical problem.  The cable had damaged a plastic pulley and had come off the track.  The damage wasn't easily fixable, and I didn't really want to mess with repairing it, so I thought I'd just keep it from falling down anymore.

You can see my solution, along with some instructions for removing the door trim to get at everything in this photoset.

Since he was not able to be there at Jenna's birth, Becky's dad came this weekend to meet her for the first time.  We had a wonderful time.  Becky and I were both so glad that he could come so soon.

I thought this shot turned out really well considering the lighting conditions.  It appears to be painstakingly-posed, but was actually completely candid.

Now that we're home, I finally got a chance to process and upload my photos from birth on Friday morning to the homecoming today.  Warning, there are a couple of gooey baby shots from the delivery, but nothing to bad (I kept a few private).

Click the photo for my set on Flickr.

In addition, you can check out Jen and Dave's set from their visit Sunday evening to bring some Chipotle to a tired daddy, just like I did for Dave when James was born.

For those itching for pictures, but not patient enough to wait for me to upload mine, they can check out my dad's blog.

We're doing OK.  We're pretty tired.  We plan on taking advantage of the nursery tonight so we can be rested for when we go home and don't have a fully-staffed nursery.

This morning, at 7:37am CST, Jenna Evelyn Miller was born, one day early, by c-section. She had turned since our last ultrasound earlier in the week and was breach (breech? beached?).

Everything is fine and Becky and Jenna are both resting.

Evidently, this is the time of year when all the cool software developers have their babies.

Pictures are coming, I'm blogging from the delivery room

[UPDATE: 11:30am]  I forgot to include the stats.  7 lbs 15 oz, 20 inches.  Will get pictures up this afternoon.  Lots to do!

Well, another Thanksgiving, another delicious fried turkey.  We had a great time.  Becky's parents came on Tuesday and we've been having alot of fun since then.  My parent's came about lunch time, and my Dad and I cooked the turkey.

This year, I did a half-and-half turkey again.  Half flavored with injected Chipotle Tabasco, and the other half with a garlic and herb injectable marinade.  I got a bit lazy this year and forgot to pick up the peanut oil.  Thankfully, a store was open in the morning, and I got some.  As a result, it was a different brand than I normally get.  Unfortunately, when the time came to start, I discovered it was not enough oil.  Thankfully, the store was still open and I was able to get another box.

We did the best job so far of bringing the turkey up to temperature, so there wasn't near as much "volcano effect" as usual since there wasn't alot of condensation or other external moisture.  Everything went perfectly.  The bird turned out excellently (as usual) and was fantastic.  It, along with the other excellent foods prepared by the girls, made for an excellent meal.

Unfortunately, Becky's dad wasn't feeling well and was unable to participate fully.  He's feeling much better now, though.

Check out my turkey photoset and the other photos near them for the fun.  I'm sure my dad's pictures will be up shortly as well.

In a followup to my last post, I was 26th in line for 24 XBox360's this morning at Costco.  At least my friend Yong was 18th in line.  He called me as I was just waking up, and I set a record for getting ready and getting to Costco.

The guy in front of me (#25) who just missed out started getting really mad and yelling, setting a really good example for his kid.  I thought the manager handled it really well.  In fact, the whole operation was pretty smooth.  They gave people numbers and took their Costco cards and said, "come back at 8:30".

Well, looks like I won't be getting my hands on an XBox360 tonight.  My job actually requires me to do some work, and I didn't get in line in time.  I heard some crazy stories from some people in line.  One guy drove several hours for his place in line.  I figured Wal-Mart would be my best bet since it would be open at midnight.  I was right, I just couldn't get there soon enough.

It's fine though.  I'm not terribly excited about any of the launch games.  I was just really excited about playing Halo 2 in HD.

So, I suppose I'll have to wait a while.  Boo.  Let me know if any of you guys have the hook-up.

I saw an unofficial announcement of the new Windows Live Custom Domains Beta from Dare's post.  It sounded pretty cool, and I have a domain without current mail capability, so I decided to give it a shot.

The "setup" was surprisingly painless, I merely signed up and enabled my existing passport as the "administrator", and it told me the settings I should enter for the DNS mail exchanger (MX) entry.  No problem.  It quickly verified the settings and told me everything was set up.  Fantastic!

I added a new account, and it said it was ready.  Here's where the fun begins.  If you haven't figured it out, you're basically getting hotmail accounts that are hooked up to your own domain name.  That's cool, despite the fact that it's hotmail, which still sucks in my opinion compared to GMail, despite the wider offering of calendaring and reminders.  (Tons of in your face adds and not very many features)  So, now, I have to figure out how to sign out of my current passport account and sign in with my "new" one to test it out.  I don't know if anyone has trouble with that, but it never works for me.  After logging off and logging back on, I visited hotmail and was in.

Unfortunately, Hotmail still has no "forwarding" functionality that I'm aware of, so this really isn't giving me anything useful.  Now, I can get email at a nice address, but I still have to go out of my way to go get it.  I'd rather have it forwarded to wherever I want.

Additionally, now I have 2 passports, and there seems to be no support for being logged into two passport accounts simultaneously, bringing up a whole variety of issues. And I can't get rid of the original passport because it is the "administrator" account.

In my opinion, the most likely usage scenario for this is bloggers or other content authors who have purchased their own domain, and want the "coolness" and other identity benefits of getting mail at that domain.  The current functionality doesn't seem to support that scenario in an optimal way.  I think it would be far better to be able to associate other email accounts with the same passport and be able to specify either to receive that email through hotmail or to forward to another account.  I don't want to create and manage a bunch of passports just to have a couple of extra email aliases.

(some photos are from my Dad's Flickr account. clicking them will take you his and not mine)

No, it's not the day of the week I take a shower...yet.  The date is fast approaching and we had our final baby shower today.  This one was the "old school" shower that we had in Belton, basically for friends of my parents who were unable to make it to Austin for our other shower.  It was a good time to catch up on some of the people that I grew up around, or were parents of my friends and such.  We also got alot of goodies for the baby.

An unexpected surprise was that Courtney showed up.  Unfortunately, I had not communicated that I would be there, so Heath didn't come, which would have been really fun.  But, Becky was telling me how glad she was that she came.

Andrew and Sara were there as usual.  We can always count on them.  Goods friends of the family Kandy Kirkley, Judy Owens, and Kathy Thompson rounded out the rest of the shower organizers (along with good ol Mom and Dad).  Thanks for all for the wonderful gifts and your hard work to help us out.  We really appreciate it.

Oh yeah.  This morning at church, we were greeted to a surprise shower by the youth department.  It was really nice, and they gave us a heap (of the 64-bit size) of diapers, which will of course be extremely useful.  It was really fun, except that they made me eat baby food, which was quite possibly the nastiest thing I have ever put in my mouth.  It was quite difficult to fight the gag reflex.  In fact, just writing about it is making me ill.  Thankfully, a couple of girls from our class of juniors also ate it.  I wouldn't have been able to do it without them.

My dad's got a whole set of pictures on his Flickr site.  I didn't take many.

As an update to a previous entry, Peter Golde has updated the PowerCollections library to be compatible with the final release of Whidbey.  Yeah! I can go back to using the official release!

Well, we had the Turkey Bowl this weekend, an annual flag football game between the juniors and seniors in our church youth group.  Since I teach the 11th grade Sunday School, I was the junior coach. We ended up losing, though through no fault of poor playing.  A good time was had by everyone.

In my role as coach, I felt the need to look more official, so I used my XBox headset to accomplish that.  Check out the whole photoset.

Another geeky post.

We built our own query system several years ago.  It used the concept of "query by example" with templates that were interpreted into SQL.  You could generate the equivalent of an "IN" clause by assigning something that implemented System.Collections.ICollection to a template property.  Recently, with the introduction of generics and the generic collections, we decided to relax that contract to IEnumerable since that's really the least common denominator of all collections.  This produced some hilarious results.  As you can imagine, anywhere where we were using strings to specify template values, they were being interpreted as collections of characters.  This manifested itself mostly by having queries return nothing, since our system properly handled Chars and treated them as strings.

But, this reminded me of a similar incident a few years ago that involved a framework that rendered objects as comma-separated values. So, instead of:

Mark, Miller

You'd get:

M, a, r, k, M, i, l, l, e, r

I thought since I had been bitten twice, I would write it down.  I usually don't forget stuff I take the time to write down.

So, the moral of the story: Remember that even though System.String implements System.Collections.IEnumerable (and now System.Collections.Generic.IEnumerable<System.Char>), you usually don't want to treat it as a collection.  You may need to special-case it.

Anyone else think of another type like this?

I ran into a nasty performance problem recently.  It involved some AJAXy type dynamic requests.  The problem was that two requests always seemed to be occuring serially rather than taking advantage of the wonders of a multithreaded server and running in parallel.  After much spelunking and debugging, it suddenly occurred to me that the handlers were marked with IRequiresSessionsState to pull a trivial piece of information out of the session.

You may not be aware, but accessing the session usually results in an exclusive lock.  Normally, this isn't a problem since users very seldomly open multiple windows or send simulataneous requests, and sessions usually represent unique users.  But fire off two simultaneous requests, and they will be processed serially.

But, if you mark your page as being "ReadOnly" (or disabled) via the EnableSessionState attribute of the @Page directive (or IReadOnlySessionState for IHttpHandlers), you'll help yourself out.  ReadOnly will get a reader lock on the state, allowing multiple readers access, while disabled (via "false") will not lock at all.  In addition, if you're running your session state out-of-process, disabled will keep you from incuring a hit from the db or other store access.

Just an interesting bit of information that thought would be useful.

We had what I deem to be the most beautiful weekend all year.  It was very cool out (70-80 in the afternoon) with a great breeze.  We took the opportunity to air out the house, which was nice because I was back in the bathroom stinking it up...with landscape block adhesive, that is.  I was building the step that surrounds the new tub, which is raised about 8 inches off the floor.  This is primarily to allow for the plumbing retrofitting, but has a nice look to it as well.  It's been a very long project, but is coming to a close finally.  All that's left to do is tile and paint.

For those photo-nazis out there, I have lots of pictures. I just haven't had a chance to get my new photo pipeline up.  I've made some enhancements and I want to make sure they are all working before I throw a few hundred pictures at it from the last several months.

Back on the subject of the beautiful weekend, we had practice for our church's annual juniors vs. seniors football game.  I'm coaching the juniors, so you can bet there will be some crazy plays as I'm not an "American football" person.  Anyway, some of my helpers and I were just providing some generic defense for them and my legs weren't prepared for that kind of sprinting and stopping, and my hamstrings are incredibly sore today.  But it was alot of fun.

My brother, Andrew, and his wife, Sara, have started a blog.  He's piggybacking off of my site for now.  Here's his inaugural post.  Let's hope we hear more from him.

Here's the logic response to Peter's experimenting:

[UPDATE] Since I've gotten some favorable response to this post, both in the comments and in email, I thought I would give some special, behind-the-scenes information

When I saw Peter's pictures, I immediately thought of the series (1,2) of photoshop trickery I did a while back. Look familiar?

Now, if you'll notice, in Peter's original, he is looking straight at the camera.  So, I had to fix the eyes and distort the nose so he's looking over at Jenkies, who is also obviously added to the scene.

After discovering he was in town without warning on Sunday.  I finally hooked up with my friend Jason Jenkins  (whom I affectionately call Jenkies) and some of his friends for dinner.  It worked out perfectly because I ended up leaving work pretty late, so I just met them down on 6th street at Hutz, which is like a 50's diner.  Pretty good stuff.  We got caught up and generally had a good time.  I'm glad that I caught him before he left town tomorrow.

Thanks for letting me crash your dinner plans!

What a geeky post title.  Well, I guess it's a geeky post.

Based on the number of people actually in the bathroom at work when I'm in there, I would think that two people entering/exiting the bathroom at the same time would be a rare event.  Yet, I've come to expect the door to magically open in front of me as my hand nears the handle, or swing violently at my face as I exit.

I always find it amazing the number of things in real life that have dualities in software.  In software, we'd solve the problem of collisions in the doorway by taking a lock on it (although locking on a public object is not always a good idea).  This becomes a problem in the real world because of visibility.  The bathroom door has no window (which is probably good), so you can't see when someone is right on the other side.  You seldom have a collision when the door has a window because you can see who else is going to try to use the door before you can get there.  There are tons of "shared resources" in the world where we've created synchronization mechanisms of various authority.  I think we could learn a thing or two by observing them.

For instance, when roads intersect, we have several different ways of dealing with collisions (we sometimes call them that in the software world as well.):

• Raw intersection - No traffic signs or anything. Typically found on dirt roads where traffic is scarce and the probability of collision is low.
• Yield - One street is a lower priority and "yields" the intersection to the other road.
• Stop signs - you see where I'm going
• Flashing Lights
• Traffic Lights
• Traffic circle - This one always amuses me.  It is actually a very efficient means of managing an intersection IF the drivers are familiar with navigating it.  If they are not, hilarity ensues.
• Overpass

And there are tons of "in-between" flavors.  Hopefully you see what I'm getting at.  The granularity of synchronization in software can be just as complex.  Simple locks, Mutexes, Reader/Writer locks, etc.

Where am I going with this? I don't know.  I just thought it was interesting how many real-world examples of synchronization there are, and how we avoid them in different scenarios, sometimes delegating that responsibility, sometimes taking a more strict position. Prioritizing etc.

That is all.

Yup, it's my Dad's birthday again.  This next year of his life holds alot of excitement for him as he becomes a grandfather.  Happy Birthday Grandpa!

I've been distracted all morning, drooling over the C# 3.0 features.  First, I was upset that they would tease us with 3.0 features before 2.0 is even released yet (and it's still a little silly), but being able to download, play with them, and run them makes a world of difference.  Here's my favorites distilled for those who don't want to check it out.

• Tons of type inference stuff.
• List<int> list = new List<int>();
• becomes
• var list = new List<int>();
• I'm not sure how I feel about "var".  It makes it feel a little like javascript.  I can see how that makes the language less ambiguous, and three letters isn't that bad.
• Tons of initialization stuff
• Initialize any collection-type-thing like you would an array. (new List<int> {1,2,3,4})
• Intialize objects with a named-parameter feel (new Person {FirstName="Mark", LastName="Miller} //not a constructor)
• A few AOP-ish goodies with extension methods - This is extremely cool.  Add methods to string, or anything else.  Very sweet.
• "Fix" the anonymous delegate syntax with lambda expressions
• delegate(int x) {return x+1;}
• becomes
• x => x + 1
• This will be hard to approach for some, but I think it's great
• Anonymous Types - This is excellent for working with data where you don't really need a formal type, you just need to work with some data.
• Language Integrated Query - This is the grand-daddy of them all.  Query against objects, query against XML, query against relational data, query against anything!  All using first-class features of the language!  I'm pretty excited about this.

I'm dissapointed in the lack of first-class duck typing support (late binding).  Yeah, we get half-way there through the use of query and anonymous classes, but there's some scenarios where that seems like hammering a tack with a sledgehammer.

I'm really excited in the innovation I see in the CLR-world.  Sure, lots of the above represent old ideas, but the query stuff represents big innovation in that space that fits right in where the "hurt" is.

A while back, I showed you my file-based viewstate persistence solution.  Thanks to Google search hits and traffic from Scott Hanselman's analysis, it's been one of my more popular entries.  With ASP.net's improvements in this area, I felt that it was due for an update.  So, here's a quick whack at it.  The usual disclaimers apply.

2.0 adds the notion of "control state" to state persistence, which is very cool.  It's an opt-in mechanism for things that need to survive postbacks even if ViewState is turned off.  In addition, there's some new flexibility with page adapters and such, but we'll ignore that complexity for now and go for a direct port of my old sample, but include the new ControlState mechanism.

public class FileBasedPageStatePersister : HiddenFieldPageStatePersister {

      public FileBasedPageStatePersister(Page page) : base(page) {}

      public override void Load() {

            //let the base class do its thing

            base.Load();

            //get the control state

            object baseControlState = base.ControlState;

            if (baseControlState != null) {

                  //the control state should be our Guid

                  Guid guid = (Guid)baseControlState;

                  //read the contents of the file and set the two states

                  using (TextReader reader = new StreamReader(CreateOfflineViewStateFilePath(guid))) {

                        Pair pair = this.StateFormatter.Deserialize(reader.ReadToEnd()) as Pair;

                        base.ViewState = pair.First;

                        base.ControlState = pair.Second;

                  }

            }

      }

      public override void Save() {

            //create a guid for this viewstate

            Guid guid = Guid.NewGuid();

            //serialize the states into a temp file

            using (TextWriter writer = new StreamWriter(CreateOfflineViewStateFilePath(guid))) {

                  Pair pair = new Pair(base.ViewState, base.ControlState);

                  writer.Write(this.StateFormatter.Serialize(pair));

            }

            //trick the normal system into thinking all it needs to save is the guid

            base.ControlState = guid;

            base.ViewState = null;

            base.Save();

      }

      string CreateOfflineViewStateFilePath(Guid guid) {

            //TODO: put these files whereever you like

            return Path.Combine(Path.GetTempPath(), string.Format("{0}.viewstate", guid));

      }

}

So, we immediately see that it's much shorter.  This is because ASP.net uses a mechanism very similar to my 1.1 solution, so alot of the plumbing is built-in. The only thing you need to do to use it is override the PageStatePersister property on Page and return one of these. Again, we're piggybacking on the "hidden field" persistence mechanism and using that to store our Guid for the request.  Not much different, and I'm pretty happy to say that converting to this model from my old is very simple.

Another interesting idea would be to leave the ControlState in the hidden field, and only store the ViewState in the file. it would be a simple change that I'll leave as an exercise to you.  Then, you could be very aggresive about purging old or large files without worrying about breaking anything (provided of course that you've made your controls tolerant to such a method).

My friend Peter and I often use Remote Assistance to collaborate on projects.  He and I were doing some things today in Visual Studio, and while I was watching, a beautiful window appeared that showed the open files and windows and such, complete with appropriate icons. "Whoa!", I said, "What was that?!"  "What", he replied, "this?"  The window re-appeared.  Turns out, it was the Ctrl-Tab window.  For some reason, I never even thought of using it to browse the open windows. I always assumed I had to navigate the frightful tabbed interface, which just might actually be usable with that little trick.

I felt better when I typed in a type name and Intellisense didn't recongnize it.  A quick right-click->Resolve instantly added the appropriate using statement.  Peter hadn't seen that feature.  Although I guess Ctrl-Tab's been a standard for much longer than Resolve.

I blogged a few days ago about a crazy problem I had with garbage collection in ASP.net under 2.0.  I finally tracked the problem down to Array.Sort.  I created a framework for working with large sets of data in a dynamic way.  This allows us to group data and do other complex statistical things based on fairly open-ended user input, rather than having to write special case code for each scenario.  It uses some reflection to be able to drill into objects.  When sorting, we pass in a dynamic IComparer that can drill into each object and do dynamic comparisons.  Unfortunately, many of our algorithms were dependent on sorting the data first.  This was causing a huge number of allocations due to drilling in and boxing lots of value types.  And, the nature of the sort causes that to happen multiple times per item.

Under 1.1, we took the hit on memory.  It didn't take that long, and it was soon collected.  Under 2.0, the GC seems to recognize this allocation pattern early and proactively begins collecting aggresively.  The problem seems to be that this slows down the sort tremendously, to the point where it essentially comes to a halt.  After a long time, you get a bizarre looking exception about a failed sort from deep in the framework.

What I can't figure out is, during all this time, there's still plenty of memory, and activity on other requests is not impacted horribly.

Well, I took a long hard look at some of the operations, and re-implemented them with a hashing strategy rather than relying on a sort.  As it turns out, for most cases, this is much more efficient.  Long story short, overnight stress testing turned up with clean results this morning.

I've talked about church bulletin humor before. Today, I experienced it first hand. Our church publishes the Wednesday night meal menu in the bulletin. I suppose this is so families can plan around it. I don't think anyone is going to have the church dinner this Wednesday. It read:

Menu: Poopyseed Chicken over rice, vegetable, rolls & dessert.

It was all I could do to keep from falling out of the pew laughing.

This is awesome.  Joe Duffy reveals what I had suspected.  A change to the CLR that will fix the issues I've previously discussed about nullable types in version 2.0!  From his blog:

The core of this change is that the IL box instruction has been modified to recognize Nullable<T>s. For non-Nullables, behavior remains the same; but upon seeing one, it inspects its HasValue property. If HasValue is true, box peeks inside the structure, extracts the T value, and boxes that instead; otherwise, box simply leaves behind a null reference. Obviously, unbox has also been changed to allow nulls to be unboxed back into Nullable<T> structures. This had a rippling effect in the CLR codebase and also required changes to late-bound semantics to mimic the static case.

This is fantastic, and reveals just how strong Microsoft's commitment is to the development community.  I gave my feedback on this before.  I felt it was a problem that aware developers could understand and live with, but I felt that novice developers would struggle with it, and ultimately it would make the feature, and the platform less understandable and approachable.

As you can tell from my earlier post, I had pretty much decided that MS would be unable to fix it at this late stage in the game, and that would be a shame.  But, thanks to some good decision making, they've done it.  Also, the solution was quite similar to my suggestion, I'm happy to say.

Be sure to follow through and read Somasegar's post on the subject.

I finally got around to upgrading the ol' blog. I was just getting too much trackback spam.

Sometime I'll get around to customizing this new theme. I was getting tired of the old one.

A few months ago, I had an entry that showed how to easily get to 32-bit explorer land within 64-bit WindowsXP using Internet Explorer to navigate the file system.  This makes it possible to use 32-bit shell extensions.  In Vista (and possible the IE7 beta on XP), this behavior appears to have changed.  Navigating to the file system simply opens up a new explorer window in the current explorer process rather than loading it within the IE frame.  This is the only gripe I have so far on Vista, and it's probably an IE change, and probably by design.  I'm sure this was changed to reduce the surface area for possible phishing schemes I can think of, but it sure is annoying.

I've seen some possible workarounds on TweakVista and elsewhere, but none that I found satisfactory (I don't want to run the 32-bit explorer as my shell).  So, I may see about throwing together a little app that can host a 32-bit explorer process so I can use my shell extensions like TortioseSVN.

As if I didn't have enough fun stuff to play with, the first Windows Vista beta was released last week.  I put it on my little laptop first, where it ran very well, but I was disappointed that the new visuals didn't run on the crappy video card it has.  So, last night, I put the 64-bit version on my PC, which has a recent ATI card on it.  Everything runs great on it and it's quite beautiful.  Both installs I've done have been utterly trouble free.  It brought back pleasant memories of installing the 95 beta and waiting with anticipation through the "Starting windows for the first time" screen, which always reminded me of that cereal commercial..."taste it again... for the first time".

This evening, I'll be putting my apps back on the PC, so we'll see if I run across any problems there.

Becky's dad came down this weekend and we caught a Round Rock Express game.  It was really fun. I got me a huge hot dog.  We were on the third base foul line, but didn't get any balls near us.  They were playing the team from Colorado Springs.  The "Sky Sox" I believe.  Then, on Saturday, we picked up Becky's mom from the airport and headed to my favorite restaurant, P.F. Chang's.  After taking Becky's dad to the airport Sunday afternoon, Becky, her mom, and I headed to Belton, where we met up with my parents and ate at the new Roadhouse (warning, link plays annoying music) in Temple, where I finally got to pay for some food.

Wow, I can't believe it's been 5 days and I haven't made an entry about the 4th of July fun.  We spent the weekend in Belton with my family.  On Sunday, we hooked up with Heath and Courtney Robinson and their two sons, Gage and Soren. It was quite fun to catch up with them and see how big their kids are getting. We took them to the mall and into the arcade that I think used to be Eckerds.  Watching them play ski-ball and air hockey,  with Soren barely able to see over the edge of the table was a blast. Here's the photo set of our meeting.

On Monday, the 4th, it was time for the annual Miller 4th of July Olympics!  Usually, my mom comes up with a bunch of crazy games, and we play them and declare winners and such.  This year, Andrew wanted to be in charge of the games.  He did a pretty good job.  We started with the bean bag toss, where you try to knock wooden blocks with animal pictures on them off a saw horse from across the yard. Then, we set up the casting competition, where we used a standard fishing pole equipped with a foam ball and tried to cast it into a pool.  This was quite challenging.  I got some pretty good shots of the moment when the ball hit the water.  After that, we attempted to drop quarters into various sizes containers which were submerged in water.  We all seemed to have drastically different theories about what would work, and oddly enough, most of them worked pretty well.  Most involved harnessing the rotational inertia of the quarter to prevent it from fluttering as it sank. Then, it was on to one hole of tennis ball golf, where you had to navigate a course with a tennis ball and 9 iron, which was also quite entertaining.  That was all for the outdoor games.  Next, we stacked Jenga blocks end to end to see who could get the highest.  For some reason, the girls were much better at that game.  After that there was a heated game of what we call "ball game", which is simply throwing ping pong balls in a trash can, in order to break a 3-way tie for second.  Once 4 place was settled, it ended in a sudden death round of "ball game" for second place.  The prizes were "winners choice" between:

• Some foam balls
• A pocket knife
• A vanilla scented candle
• A small stuffed monkey
• A velcro paddle and ball set

It was great fun. Check out the whole set for the games of the 3rd Julympiad.

Andrew made his patented secret recipe trail mix, which is alot like a bowl of candy.  His wife Sara made a delicious cake.  And we had lots of other goodies.  We didn't get to shoot any fireworks this year, which was unfortunate, but that just means we'll have to make up for it next year.  I hope everyone else had as much fun as we did.

My boss and I spent Wednesday and Thursday in Phoenix, Arizona on a business trip.  We were evangelizing some internal tools we've created over the last several years.  We left early Wednesday morning on Southwest Airlines and had a stop in El Paso, where I changed seats into the best coach seat I've ever sat in.  It was just behind the emergency exit row, and the seats were arranged such that there was no seat in front of me.

Let me just say something about Phoenix.  It is HOT!  We came up with a slogan for Phoenix:

Hell is cold in Phoenix

Anyway, the trip went well.  And our tools were well received.  For the first time, I made sure that my GPS was turned on as much as possible to enable me to geo-code my photos.  I used the WWMX Location Stamper from Microsoft Research to put the GPS track data into the photos.  I was hoping to integrate them into Google Earth, but they are no longer taking orders for the plus version which allows GPS track data to be integrated.

Also, in a bizarre coincidence, my friend Jeff Flint, who lives in the Seattle area, was in Phoenix on a sort of baseball tour.  So, Wednesday night, I ditched my boss and headed to the ballpark.  I was worried about the sun and the heat, but on the way there, I noticed that the smoke from the fires in California was making it much less intense.  Then, when I got there, an even better surprise.  The roof was closed and the park was air-conditioned, making it very pleasant.  Jeff and I watched the game, chatted, and generally caught up, which was great.  He managed to catch two balls during batting practice.

This weekend was a momentous occasion for my bathroom project.  I got the tub into place in the bathroom!  With the help of my brother, dad, and friend Dave (Thanks a million!), we successfully navigated the maze of narrow doors and hallways from the garage to the master bathroom. (I'm still not quite sure how) Anyway, the tub is in place, ready for levelling and hooking up.  After that, it's time to prepare the walls and get ready for tiling and installing the new pedestal sink.  I've been stalled for a while waiting for the right opportunity to get everyone together to help carry it in there, but now the project can continue forward.  The photoset of this project is getting too big and confusing to just link to the whole thing, so here's a link to the start of this weekend's pictures within the set.

As usual, I was busy, so my Dad got more action shots than me.  I'll link to his pictures when he gets them up.

Despite being pretty old, Becky's 95 Nissan Maxima still runs great.  The alternator recently went out, so I replaced it.  Being more of a geek than a gearhead, I wouldn't have attempted this a few years ago. But, after some help from my buddy Mark Leech and the internet, I had it running again.  The Maxima does not appear to be designed for replacing the alternator without several extra double-jointed limbs and a device that allows matter to pass through other matter.  I had to remove or loosen quite a few items including the A/C compressor and radiator fans to get it out.  I also had trouble with the belt tensioner being frozen in place.  A new pair of sweet vise grips and a hammer alleviated that problem.

Here's a link to the related photoset.  My hands were pretty dirty during most of the ordeal, so I was reluctant to pick up my camera. As a result, there are not that many pictures.  Enjoy them anyway.

Those of you who follow my vacationing activities know that I have a certain affinity for aquariums, which is odd because one of my biggest phobias involves murky water.  Anyway, while in New Orleans over the weekend, we stopped by the aquarium (map) after the wedding. Enjoy the photos.

This past weekend, we (Me, Becky, my Mom and Dad, and my aunt Kenny) piled in a rented Ford Expedition and headed to New Orleans where my cousin Jeremy was getting married.  We stayed in the J.W. Marriot on Canal street where we had a great view of Canal street and much of the city.  All the wedding festivities went well.  We were very tired from the drive, and had to duck out early from several of the events, but it was really great.  We hit the aquarium (pictures coming soon) and took a stroll around the French Quarter, which I really didn't like at all.  Something about lots of people crammed into a confined space that smells like a mixture of B.O. and pee just seems to get to me for some strange reason.  I've got photo sets of the rehearsal dinner and the wedding/reception.  My dad and I also created a Flickr group to pool all our pictures.

I also played with myGmaps and created this little map that I will continue to annotate with stuff from the trip.

It was really fun to see the family and participate in the festivities, but I probably won't be planning any more New Orleans vacations any time soon.

Things are coming along very nicely in my bathroom remodeling project.  The whole thing started out with me re-caulking the tub and has resulted in me replacing the outside of my house and completely remodeling the bathroom. Long story.  Anyway, I picked up the last of the hardware this weekend and we've picked tile and paint colors.  Here's a rundown of what's occurred in the bathroom:

• Pretty much everything has been removed from the bathroom, aside from the toilet (so far. It may eventually get replaced as well). This includes:
  • Old tub
  • wall tile in the shower area
  • sheet rock on strategic walls
  • old double-sink counter-top and cabinets
  • carpet and linoleum
  • wallpaper
• We removed the wall that separated the main bathroom area from what I refer to as the "toilet nook".
• We capped off a set of sink supply lines and drains.
• We moved another set of sink supply lines and drains over about 2 feet to accommodate a new pedestal sink.

I'm currently in the process of running new plumbing from the old tub/shower supply lines to the new shower hardware and a separate Roman tub faucet. I've decided I like plumbing quite a bit.  I've always wanted an excuse to play with a blowtorch.

After the plumbing is complete, I've got to run two new circuits to run the pump and heater on the tub.  That should be fun as well.  The easiest way would probably be to run conduit from the outside breaker box along the outside of the house since it's only about 20 feet.  I'd prefer coming off of the inside box, but that will be considerably harder.  I'm still evaluating the pros and cons of each approach.

Anyway, this is what has been consuming my free time lately.

So much stuff has been going on in the last few weeks.  I hate it when I get behind here.  Yes, the rumors are correct.  Becky and I are going to have a baby.  I don't really like the term "expecting".  Whenever someone says they're expecting, I always say, "I hope you're pregnant, or you're going to be dissapointed."  I also don't like the term "due".  It makes me think, "Boy, I hope we get it turned in before it's due, or we'll get points taken off".  Anyway, I was waiting to make this announcement until I could get the ultrasound picture scanned so I could share it.  But the scanner is on the fritz and I haven't had time to mess with it.

Oh, yeah, the official date is December 4th.

We have a big configuration file that maps business logic concepts to their currently used implementations so we can dynamically switch these out.  Under ASP.NET 1.0, all those implementations were in assemblies with "well-known" names (meaning we know them deterministically before compile-time).  Some of the implementations were in nested classes of user controls (we'll save the debate over whether that is a good idea for another time).  This means that the ASP.NET compiler is now in charge of them, which makes their names more difficult to discover.

Luckily, there's someone looking out for us here.  The System.Web.Compilation namespace has all kinds of goodies to help us out here, namely the BuildManager class.  It has a GetType overload that at first glance appears to do exactly what we want, unfortunately it only seems to work if the assembly in question has already been loaded.  This is not usually the case when our configuration code runs the first time.  Instead, you can use a combination of GetCompiledAssembly and good ol' Assembly.GetType.  So now, instead of knowing the assembly name, we need to know the virtual path to the compiled control. So here's a snippet that does generally what I want:

if (!String.IsNullOrEmpty(urlString)) {

    System.Reflection.Assembly assembly = BuildManager.GetCompiledAssembly(urlString);

    theTypeIWant = assembly.GetType(typeString, true);

}

else {

    theTypeIWant = Type.GetType(typeString, true);

}

John Lam claims that C#'s "using" blocks aren't "extensible to let us do arbitrary things".  He shows us an example of doing arbitrary things in statement blocks in Ruby.  I'll agree that his example is slick, using a continuation to yield control to the block, but there's certainly nothing keeping you from getting same functionality in C#.  The "using" block is simply a mechanism that utilizes the Dispose pattern to do things when you're done with them.  I've done everything from the standard releasing of resources to implementing reader/writer locks with them.

To speak to John's example, there's nothing keeping you from creating a wrapper or subclass that calls SetInfo in the Dispose method to accomplish the same thing.  Or, you could create a generic factory pattern that uses delegates to define the creation and disposing actions: 

public delegate T Creator<T>();

public class DisposingFactory<T> : IDisposable {

    Creator<T> creator;

    Action<T> disposeAction;

    public DisposingFactory(Creator<T> creator, Action<T> disposeAction) {

        this.creator = creator;

        this.disposeAction = disposeAction;

    bool valueCreated = false;

    private T value;

    public T Value {

        get {

            if (!valueCreated) {

            return value;

    public void Dispose() {

        if (valueCreated) {

With Don Box doing all manner of crazyness with anonymous delegates recently, I decided to do some experimenting of my own. While doing so, I ran into an interesting problem.  I was toying with a robust action scheduling mechanism that serializes actions to disk to make sure that they won't be lost in the case where the host process is stopped for some reason.

I was using the generic Action delegate to represent the actions and using anonymous delegates to inject things like action rescheduling.  I was pleased to see that basic anonymous delegates were serialized without issue.  But, when I started to use the closure features of anonymous delegates, it stopped working.  I was dissapointed, especially when I figured out why.

When you create an anonymous delegate without using outer variables, it is hoisted into the enclosing class as a private method with a compiler-generated name (that appears to be generated based on a combination of the signature and some randomness).  For example:

[Serializable]
public class Example {
  void Test() {
    Action action = delegate(DateTime scheduledTime) {
      Console.WriteLine("blah");
    };
  }
}

This actually turns into something like:

[Serializable]
public class Example {
  void Test() {
    Action action = new Action(CompilerGeneratedName);
  }

  void CompilerGeneratedName(DateTime dateTime) {
    Console.WriteLine("blah");
  }
}

Actually, it does some niftyness to cache the delegate, but that's not important for this example. As you can see, serialization isn't a problem here.  However, if you use an outer variable within the method, the compiler hoists both the method and the variable into a nested class so it's available later when the delegate actually runs.  For example:

[Serializable]
public class Example {
  void Test() {
    string foo = "blah";
    Action action = delegate(DateTime scheduledTime) {
      Console.WriteLine(foo);
    };
  }
}

This turns into something like:

[Serializable]
public class Example {
  void Test() {
    CompilerGeneratedClassName something = new CompilerGeneratedClassName();
    something.foo = "blah";
    Action action = new Action(something.CompilerGeneratedName);
  }

  private class CompilerGeneratedClassName {
    public string foo;

    void CompilerGeneratedName(DateTime dateTime) {
      Console.WriteLine(foo);
    }
}

Pretty cool, eh? Yeah, so what's the problem?  Well, the nested class is not marked with SerializableAttribute, so it can't be serialized, which makes the delegate serialization fail.  This seems like a big problem to me.  There may be a legitimate reason for this, but I don't see it.  I think the compiler ought to decorate the nested class if the enclosing class is also decorated.

There may be a way around this, but I haven't found it yet.  Any suggestions?

[Update] If you think this is a problem too, then vote for it.

With Becky's family in town this weekend, I took her brother Ben to play some frisbee golf.  We met up with Dave at the Wells Branch course near our house.  The weather was really nice despite a nagging wind which made it a bit tough.  As usual, there were some great moments and some mishaps.  I brought the camera along and captured some choice moments like this one of Dave leaping across the stream after retrieving a stray disc.  The pictures turned out really well.  Check out my photoset!

This weekend, Becky had her masters recital.  She's been at UT for the last two years getting her masters in French Horn performance.  It was fabulous! She played what was, in my opinion, an incredibly hard program.  One piece was difficult enough that she went through about a dozen accompanists before one could commit to the piece, which was modern and weird, but exceptionally performed. Congratulations Becky!

Her parents and brothers were in town, as were my parents, brother and sister-in law.  It was a great time.  Jen and Dave were there as well.  Since there were 3 Flickr-ers there, I created a Flickr group to share all the photos.  Check it out.  There are some great shots from everyone. Our mothers brought a huge spread for the reception after the recital.  Thanks again for that you guys. After the reception, the gang came back to our place for some fajitas a la Mark and Dave, which seemed to be well received.

The weekend was exhausting overall and left me feeling sick Sunday morning.  But I'm feeling better now.  Bring on the new Halo maps!

It's my friend Peter's birthday today.  I'd tell you how old he is, but I don't even remember how old I am.  Here's a picture from a couple of years back of Peter in the Olive Garden in Waco, Texas.  I believe the haircut is a few revisions behind, but the goofy grin is up to date.  Sometime, we'll make it out to Cali for a visit and stay at their new place.

Happy Birthday, buddy.  I believe I have the distinction of being the first to say it online.

We're making the move to 64-bit at work, and one of the things that's annoying me the most is all the 32-bit shell extensions that I rely on and didn't realize it.  For example, we use Subversion for source control and use the excellent TortoiseSVN shell extension to work with it from explorer.  Since it's a 32-bit extension, it doesn't show up in the context menu.

There are two workarounds I've found for using these 32-bit extensions.

1. Use the 32-bit explorer.exe in the SysWow64 directory.  You have to have the "Launch folder windows in a separate process" option turned on, otherwise it will just see that explorer is already running and start a new 64-bit window instead of a new 32-bit process.
2. Use 32-bit IE.  There's already a shortcut to it by default in the start menu.  Just fire it up and navigate to the filesystem instead of a web page.  Voila! 32-bit extensions start showing up.  I like this method since I don't have to have a bunch of explorer processes for each window.

There's probably a cleaner way of using the 32-bit explorer, but I haven't figured it out yet.

Becky's dad was in the Dallas/Fort Worth area for a conference, and "dropped by"  By dropping by, I mean he took a 6 hour round trip out of his way.  I suppose that's better than the 16 hour round trip it would be from El Paso.  We went to Pasado's for dinner Friday night and had a nice time catching up.  Thanks for stopping by!

My dad came down today to help me with a bathroom remodelling project.  We were basically removing a wall in the bathroom, but it was a little more complicated.  The wall goes all the way to the roof, and takes a couple of corners.  Luckily, the upper portion was structurally sound enough to support itself without the lower wall. Click through the picture on the left to see the stuff we did.  You can also check out the bathroom remodelling photoset for some more context.

A big thanks to my mom and dad for coming down to help.  I'm sure he'll have his pictures up soon.

[Update] Dad's got his entry up with links to pictures.

Last night, I completed my STDF file parser that I started over the weekend.  I'm pretty happy with it.  I now fully support all of the version 4 spec.  It's written with the Feb. 2005 CTP of Whidbey.  It was primarily a good example of a "real world" application, so I wanted to use it to try out some of the spiffy new features and see how they might fit into an application that was not built for the sole purpose of showing them off.

I'm not entirely sure what I should do with it now that I've built it.  There's not much non-commercial demand for something like that that I am aware of. I might be persuaded to license it for use commercially once there is a "go live" license for Whidbey.  I'm sure it will need some testing to work out issues.  I'll probably build a viewer using it and use it at work to get the kinks out of it.  Anyway, I thought it might be useful to capture how some of these features played out in a real scenario.

Lightweight Code Generation

I used attributes to annotate my record classes in order to define the "on disk" layout of the record.  I originally put the attributes on the properties of the record, but decided to move them to the class level so that I could define the fields that are only used for parsing, and not useful after that.  At runtime, I register the record types with the parser, which uses lightweight code generation to generate converters from unknown records to the concrete records.  If you're not familiar with LCG, it is essentially Reflection.Emit without the overhead of a dynamic assembly, module, or type.  If you're unfamiliar with Reflection.Emit, it is essentially generating executable IL code on the fly, which has may benefits over generating C# or some other language and running it through the compiler with CodeDOM or soemthing else. (If you're not familiar with IL, then this entry is somewhat irrelevant) Having dealt with assembly on lots of different instruction sets from 68000 to x86 to DSPs and microcontrollers, I must say that working in IL is wonderful.  I was a bit worried about the startup time for the parser, but it seems to happen very quickly.  I'll need to experiment more to come up with the overhead of the dynamic code.  Again, I was disappointed in the lack of debugging support in LCG.

Generics

Unfortunately, generics did not work into the equation near as much as I had hoped.  I did find them very useful in places where I would normally pass a Type.  Now I can have a much stronger contract on such methods using generic methods with constraints.  I must say that I love the generic collections.  Working with strongly-typed data without having to generate the classes is very nice.  I also like being able to do a custom sort with an inline anonymous delegate with closure-type semantics rather than have the overhead of a separate class with the code in a different place.

Iterators

Iterators came into play in several places.  In the pull-based record parser, it was simple to implement IEnumerable.  I believe it only took 3 or 4 lines of code.

Delegate type inference

I don't remember what the official name of this feature is, but instead of having to do something like SomeEvent += new EventHandler(SomeMethod), you can just do SomeEvent += SomeMethod.  This seems small, but I appreciated it quite a bit.

Visual Studio Enhancements

These were a very pleasant surprise.  I hadn't thought about the exercise as testing the VS enhancements.  The snippets were the most useful improvement in this project.  Implementing properties didn't make me want to rip my hair out. Just type 'prop' and hit tab and fill in the blanks.  The built-in snippets for things like exceptions, attributes, indexers, etc. all work really well.  The one for implementing an indexer/iterator as a nested class was very interesting as well. It was also easy to create my own snippets.  I also found the strongly-typed resources to be very handy.

The debugging stuff is awesome.  I love being able to mouse over variables and drill into them dynamically.  The little popup windows for exceptions are cool, but don't really give you any good information that you couldn't get before.

I found the refactoring support to be extremely useful, although it was a little hard to shift into the mode of making sure everything compiled all the time.  Before, I would jump around alot in the code, so I would leave things in a state where it didn't compile.  It worked great once I got used to it.

Well, it looks like the Lady Bears are gonna win it all.  That's really exciting.  They really deserve it.  I played in the basketball band at almost every home game while I was at Baylor.  Just heard the 'bones playing Emperial March.  Cool to see the band still doing some of the things that Dave, Jeff, and I started while we were there.

[Update] It's now official

[Update] changed 'game' to 'band'. He he

So, my recent drink of choice is also Robert Scoble's.  I found it to be one of a very small number of diet drinks that I can stand.  Among them are Diet Dr. Pepper and Diet Dr. B (a knock-off).  I find Diet Mug Root Beer to taste almost exactly the same as the regular version.

Robert, just don't leave it in the freezer and forget about it.  I wanted a cold one and the cans we're cold yet, so I thought a little freezer time would speed things up.  So, I forgot about it.  It was a mess.  It was pretty cool though.

This is what happens if you break your XBox communicator and still want to play.  Dave broke the plastic part that rests on your ears, so he's using a headband to hold it onto his head.  He said he was really hot after playing a while. Hilarious. 

Well, it's a new month, and you know what that means.  That's right, another 1GB of photos to upload to Flickr.  Most interesting of the uploads this week is my full set of 4th of July fireworks pictures.  These are from two sessions of fireworks launching.  One out west of Belton with my brother and his in-laws, and another with Jen and Dave's family out in Copperas Cove. During the later session, we were much better prepared for taking photos, so they turned out really good.  My new digital processing techniques really brought out alot of detail as well.

I have now loaded all of my pictures back to the point where I got my Canon 300D, so next comes the flood of older pictures from my old Sony DSC-S70.

I had two projects over the weekend.  One was to get my bathroom ready to install a new bathtub.  The other was an experimental coding project.

The bathroom preparation went fairly well.  I ripped out all the cabinets and countertops.  I'm glad my brother showed up unexpectedly because that countertop was incredibly heavy.  We also got alot of the carpet ripped up.  I'm going to be putting down new flooring as well.

On the coding front, as an experiment in adopting new features in Whidbey, I implemented a binary file parser for Standard Test Datalog Format (STDF) files.  These files make up 99% of the data we work with at work and that fill our many-terabyte test result database.  We have a fairly complex parser and db loader framework, implemented in C# on 1.x.  It works very well, but it was written early on in our adoption of .net with little knowledge of what the CLR could do for us. So, my experiment was basically to see how new features in Whidbey, along with my now deep experience in .net, could make the parser better.

STDF is record-based.  The spec defines alot of records, and leaves room for user-defined records.  The new parser reads chunks of the file based on the record headers and produces "unknown records".  I define the record layouts using attributes on record classes.  Then, the parser uses LCG (lightweight code generation using DynamicMethod) to generate converters to read the content of the unknown records into the concrete record classes (based on the attributes).  The benefit of using LCG is that record types could be registered or removed on the fly and the GC could collect the generated code.  I could have just as easily implemented it using on-the-fly interpretation of the attributes.  I'll measure and see how the performance works out.  The parser is pull-based, meaning that you ask it for records, or alternately just "foreach" through them using an iterator-based IEnumerable implementation, which is pretty sweet.  On top of the pull-based parser, I built an event-based "processor" where a consumer can register to receive certain record types.  This is the model used in our current parser, but after the XmlReader vs. SAX discussions, I thought exposing the pull-based approach was the right thing to do.

I had a few challenges, which I think represent work for the next version of the CLR:

• Endian-ness - To my knowledge the framework does not have any mechanism to work with binary data with non-native endian-ness.  The STDF is written in whatever endian-ness is native to the platform, so the parser must adapt.  This was a simple enough problem to solve, but now that most of the other gaps have been filled, endian-ness represents a hole in what the framework provides.
• Generics' proliferation - Generics are great, and saved me tons of code, but they have not made their way into the rest of the platform where they could be leveraged.  For instance, if I create a RecordField, there's not a simple way to do something like BinaryReader.Read() to actually get one, so I was forced into tons of ifs and switches, and passing Types around to get the work done.  It just didn't feel right.
• LCG debugging - From what I understand, this was cut from Whidbey.  The workaround for me was to have two generation paths.  One would do LCG, and the other would do traditional Reflection.Emit that could be debugged and PEVerified, etc.  The problem with this was the argument were not aligned between the two.  When doing the traditional Reflection.Emit, ldarg.0 would give you the "this" instance, which didn't exist in LCG.
• Handler registration (Generics compatibility) - Ideally, record handlers should work with concrete record types, but the way generics work a Converter is not assignable to a Converter even though Mir : StdfRecord.  Of course implementing that would complicate many things.  Interestingly, delegate(UnknownRecord unknownRecord) { return new Mir(); } will satisfy both delegate types.  So, this was just frustrating that Generics didn't help me out in solving my record handler registration problems.  There may be a solution that I'm not seeing here because of my approach.  Any ideas?

Oddly enough, I spent about equal time on both projects, but I seem to have alot more to say about the later.

[UPDATE] I realized that the entry box swallowed some of my generics syntax, so I fixed that, as well as fixing some minor spelling and grammatical errors.

My dad got the pictures up of our water heater fiasco from yesterday.  He's got just about the whole process documented in pictures.  I had actually forgotten about using the chainsaw.  Check out the photoset!

Next in the backwards march through all my old photos is a huge set of photos of our trip to Busch Gardens in Tampa, Florida.  This was my first big trip with my digital rebel, so I was a little trigger happy.  Check out the photoset.

Since I moved to a hosting company, I took down my old photo gallery to reduce bandwidth and disk space. This is significant, because one of the most frequent search hits I get is for pictures of Busch Gardens. Now they can actually see them again.

I'm slowly backfilling Flickr with photos, trying not to use up all my bandwidth before the month is over.  The latest is a photoset from last year's Florida vacation where Becky and I met up with her family for her brother Ben's wedding (look for those pictures soon).  We had a great time.  After the wedding, we visited the Florida Aquarium in Tampa.  Check out the photoset!

I've just about got my digital workflow down.  I've got a basic batch job to do the standard things to pictures (auto-contrast using levels, unsharp mask, etc).  I've figured out how to tweak the RAW settings to correct color issues and actually SAVE the settings for when I open that picture next time (which I had to do alot in the aquarium pictures because of the interesting stuff water does to color).  And I've got a process for tweaking individual pictures with things like pulling the details out of shadows (which works fantastically when working in 16-bits per channel).

Becky and I spent this weekend in Victoria Texas.  Why you ask?  Becky was playing in the Victoria Symphony!  I was really impressed with the fine arts culture of the small town.  Becky did a great job, and got to play one of the most famous 2nd horn excerpts (Beethoven's 3rd Symphony).  I got a "comp" ticket, and was basically the closest person to the stage.  I had stayed up all night Friday playing Halo 2, so I was overly tired at the concert.  I was enjoying the music quite a bit, but fighting hard to keep my eyes open.  It was very strange.  It was like my brain wanted to shut down all unecessary cycles except for listening.  I never fell asleep, but I did listen to much of the second half with my eyes closed, employing the standard techniques to not look as though I was sleeping of course.  Becky did great.  Perhaps she'll get the permanent gig!

After the concert, we went to the Sonic.  They had a credit/debit card machine built into the menu, which also conveyed useful information like "your order is being prepared" and "your order is being delivered".  It was really useful.  No fumbling coins in the food exchange.  It was sweet.  I hadn't seen those before anywhere, and I didn't expect to find it in a small texas town.  Bravo.

I've been playing with the Flickr API alot, experimenting with some different things that I have planned for the future.  One of the things I'd like to do is to create context sensitive image collages on the fly for my blog entries.  Thought I'd show you this cool example from a first-pass collage creator.

Of course most collages wouldn't have this many pictures, but I thought it was cool.  I need to do some randomizing.  I'm filling from the upper left corner in diagonals for reasons you'll see when I get it working the way I want.

I've also been playing with some client-side Flickr stuff using XmlHTTPRequest to dynamically load images for a slide show type thing like MSN spaces has.  I might upload an example of that later.

I just got back from Brad's talk at the Austin .NET User's Group meeting.  It was my first meeting, and I felt a little bad about not being a more active part of the local community.  It was a solid, interesting talk, even though I was pretty familiar with both topics (exceptions and memory management).  I managed to ask an intelligent question about a change in Whidbey regarding unhandled exceptions on all threads terminating the app rather than on the main thread only.  My question was on the ThreadAbortException, which seemed like a monkey wrench in that plan.  Turns out that there's nothing to worry about there as that exception is already pretty special.

Despite the great technical content, these were my favorite quotes (emailed to myself via my mobile so I wouldn't forget them:

• Everyone should be using ... using (referring to C#'s using blocks)
• It's like feeding peanut butter to a dog (referring to using some of the new GC (garbage collector) methods to help in memory management.)

I'm always really impressed with the CLR team's desire to do the right thing with the framework and to help developers do the right thing. Thanks for adding Austin to your "world tour", Brad. BTW, the slide template seemed like the right choice to me.

Whew, what an ordeal.  I finally got my Adobe Photoshop CS in the other day, and last night, I created a "Droplet" for batch converting all my raw files from my Canon Digital Rebel. Droplets are a really sweet feature that lets you create a little executable from recorded actions for batch operations.  So, I burned through about 2000 images, creating big jpgs suitable for uploading to my newly upgraded Flickr account.  It was getting pretty late, so I fired up an uploader an set it to upload my 1GB limit (roughly 900 pictures).

This morning, I checked my account, only to find that none of the metadata had been uploaded.  All my images appeared to have been taken on Feb 11, 2005...uh oh.  So, I set out to find out what happened.  Turns out, Photoshop saves the metadata in it's XMP format within the file. XMP is simply an rdf encoding of the data in an XML payload within the file.  It's actually pretty cool, but Flickr doesn't read this data yet.  So I set out to "fix" my pictures, since I can't upload anymore until next month and I have lots more to upload.

After looking at lots of libraries and Adobe's XMP SDK, I decided it would be easy enough to pull the data out myself.  So, I built a little app using my FlickrApi library I just created that would blast through my uploaded pictures, find the corresponding image on my local pc, pull the xmp data out of the file, and set the "date taken" on the Flickr site.  That way, I can at least organize them more easily.

It worked perfectly.  It blasted through about 900MB in less than a minute.  Look for the pictures as I tag them, annotate them, and change them from private to public.  I'll have to see if there's a way to have Photoshop preserve that data next time because I'd really like to have the rest of the metadata available.  I'll probably make my XMP parser available as well if anyone's interested.  As far as I know, there is not another managed implementation available.

I typically use the well-done MSN Web Messenger at work to avoid firewall issues, and to avoid stomping on our company's branded version of messenger (which sucks BTW).  When attempted this morning, I got the following message:

We can't sign any more people in right now. Please try signing in again later.

I wonder if it's just a web messenger problem or MSN messenger in general.

[UPDATE] Now I'm getting the ASP.NET "Server Too busy" exception, so I'm betting it's a web messenger only thing.

This is one of the coolest things I've seen in a long time.  Try my flickr name (marklio).  It lets you drill through my contacts and see their information.  Keeping clicking and you'll see all kinds of cool things.  It really helped me see Flickr as a web service rather than just a photo sharing site.  It gave me alot of ideas.  Things like using tag matching to automatically creating blog entry backgrounds that are relevant to the content.  I'm going to be playing with that.

Their API is really nice and well-documented.  Some people made a .NET wrapper for the API, but it's not up-to-date and I wasn't really impressed with the design.  I'll probably roll my own and just implement the things I need as I go.

In an earlier post, I mentioned that I wished HttpModules were more scriptable in ASP.NET.  You can easily create Controls, Pages, HttpHandlers, and web services all without having to compile anything, but as far as I know HttpModules have to be compiled and registered in the web.config in order to start working.

So, I created a ScriptableHttpModule.  You register it in the config the same as a regular module, but it allows you to create .asmodx files that are compiled and called just like regular modules and give you the same kind of dynamic compilation model as the other .asXx files.  I'm still tweaking it a bit, but it looks pretty promising.

marklio.com, as well as my dad's site bellcountyblogger.com, is now being served from a real server!  I just made the switch a little earlier today to a hosting company.  I've been really impressed with them so far.  The transition was absolutely seamless, although I am still hammering out some email details that were not available before.  I'm discontinuing the gallery in favor of hosting all my images on Flickr.  That way all those images won't take a bit out of my bandwidth (although I have plenty).  Hopefully that will provide a better experience for everyone, especially once they integrate photo printing.  My redirector will continue redirecting the old dnsalias addresses.  Hopefully those will all get cleaned up before my port 80 gets blocked. Up until now, I've been relying on the business class cable modem service provided by my employer, but they're discontinuing that soon and the standard package blocks port 80.

I just ran across BlogMap, a cool project that attempts to organize RSS information by location.  It lets you "geo-code" your blog so that it can be browsed and searched by location. It doesn't put the icon exactly where you live since it's by zip code rather than exact address, but it's pretty close.  My house is just under the little blob in the lower-right-hand corner (it's a park).

Anyway, once you've geo-coded your site, your feed is added and can be found through a somewhat clumsy (at this point) map, or by searching for a city.  The system needs some work to be really useful, but it's pretty dang cool!  Chandu has done some excellent work on it and I hope he continues to make this into an extremely useful tool.

It really adds alot of scope to content to know where it's coming from.

Even though it has some objectionable language, I thought this video was funny enough to link to. Evidently, a group of guys had been playing Halo 2 late into the night, when one of them fell asleep while playing.  To make matters worse, he begins snoring loudly into his headset.  So, his character is just standing there snoring.  One guy fires up the VCR and starts recording.  Then they all begin abusing the snoring guy.  Yelling at him to wake him up, pushing him off cliffs, and surrounding him with explosive fusion cores and setting them off which sends him into the stratosphere.  Again, it does has some objectionable language.

Although I haven't experienced this scenario, playing Halo 2 online is very interesting from a social standpoint.  To me, it's been alot more like playing a sport than a video game.  When you're playing online, there are no AI players.  Every character has a real human controlling it.  Being able to communicate with your teammates adds alot as well.  It's alot like playing paintball or lazertag in really elaborate arenas, only tons cheaper.  If you think about it that way, the XBox is very inexpensive compared to what you'd have to pay for that kind of entertainment.  It's a fantastically easy way for me to get together with my friends and do something without having to get them all in one place. (at least my friends who have XBoxes...hint...hint)  And it's also been an excuse to get to know people I wouldn't otherwise have much in common with.

I never got a chance to wish a happy birthday to B-Dub.  His birthday is pretty close to mine and we usually hook up with he and Jan at some point for some dinner.  Somehow, we've neglected to do that yet, despite the fact that we live in the same city.  Maybe he should get an XBox and Halo 2, then those pesky few miles would become irrelevant.

Happy belated birthday, D-Dub.

Keep an eye on this space for a photo.  I've got the perfect one, but I don't have access to it at the moment.

I recently announced my dad's foray into the world of blogging.  Well, after some issues with MSN spaces, we've decided to abandon it in favor of a more controlled solution.

So, here's his new location, complete with fancy domain name, BellCountyBlogger.com.  I'm hosting his blog now using the same software I use.  We're still working the kinks out as of today, but he's already putting content up.

I recently recommended MSN Spaces to my dad to start up a blog.  He got really excited about it and began posting his thoughts and photographs.  Today, we discovered that for people to leave comments, they must have a .NET passport.  Personally, I have nothing against passport.  I think it's great, but not everyone does.  There are lots of people scared to create a passport because they think there is some kind of privacy issue involved. I can see this as a defense against comment spam on the blogs, but to my dad, it's a barrier for his friends and family to join in the conversation.  We're looking into all the options, but I may recommend he look elsewhere for his blog hosting needs.

A colleague at work turned me on the Flickr the other day.  I had looked at it before, but didn't really get it.  Since my dad set up his MSN space, I've been jealous of the nice photo sharing integration, and I've been disappointed in my gallery software, nGallery.  Development seems to have stalled far short of the features I would like to have.  It does alot of cool stuff well, but it's organizational and social features leave much to be desired. (difficult to read comments, poor RSS support, etc.)

I went ahead and created a flickr account and uploaded a few of my best photos.  The organizational features are really cool, and it's got alot of social features, especially for other flickr users.  For those of you browsing on my actual site rather than RSS, you can see I'm playing with some integration with my site.  Speaking of RSS, flickr has deep RSS/Atom feed support.  For instance it's really easy to use the organization features of flickr to create an RSS feed of hamster pictures.  Here's my photostream RSS, although the Atom feed seems more streamlined and includes my buddy icon.

I think I'll keep my gallery around for some things.  I really like nGallery's features that let you order prints directly from the gallery.  But I'll probably let flickr be my artistic outlet.

I recently mentioned in passing that while I was growing up I slept on my roof on occasion.  This was usually to have a good view of some some meteor shower, or catch a lunar eclipse.  Since I mentioned it, I've had several inquiries as to how I kept from falling off in the middle of the night.  So I decided to do a little write-up on how to sleep on the roof without killing yourself.

First, it's important to find the optimum sleeping bag.  You don't want one with that slick material on the outside, or it will slide down the roof.  The cloth kind will create a velcro effect with standard asphalt shingles and keep you on the roof.  It's also important to align yourself so your feet are aimed down the slope so you don't roll.  You may also want a sleeping bag with cloth on the inside as well so you don't slowly slide toward the bottom of the bag.  That way you won't have to wake up periodically and push yourself up back up to the top.

That's pretty much all there is to it.  Of course, different roofs will have different pitches and shingle types and some may be completely unsuitable for sleeping, so you'll have to use your judgement.

After months of prodding, I finally got my dad to start a blog.  I think MSN spaces will suit him well since he likes to take pictures and spaces has some nice photo integration.  I think it will end up being an interesting collection of family information, pictures of anything and everything, and hilarity.

Check out his inaugural post.  Hopefully, he'll like the format and continue.

[UDPATE] I've killed the old links above since he's got a new blog and his MSN Space is defunct.  Go to BellCountyBlogger.com instead.

Over the lunch break, I took a test recommended by a friend to figure out how nerdy I am.  I don't think it's much of a shock to those who know me.

Update: I've since taken it again without trying to get an inconsistent score have gotten a fairly wide range of values, as high as 96.  So, take the number with a grain of salt. 

I just got finished debugging a crazy problem with some C# code.  This particular code is part of an application that deals with file spooling, and it deals with alot of ambiguous file locking issues by always locking greedily.  Any spooling task that is unable to gain an exclusive lock on a file simply assumes another thread must be working on the file and it leaves it alone.

The developer used a pattern that handles System.IO.IOException and assumes that any IOException must be because of a concurrency issue.  The problem with this is that there are lots of calls that can cause file IO that you may be unaware of.  In this case, there was an assembly binding issue caused by some plugin-style dynamic loading that was throwing System.IO.FileLoadException (Which actually seems to be out of place as a subclass of IOException since it is specific to assembly loading and not IO in general).  The pattern in the code was assuming that, in general, any IOException was not an exceptional event and signified another condition. So, the task never did any work and never reported the exceptional condition.

Eric Gunnerson wrote a nice overview piece on exceptions in C# on msdn.  Some of his guidelines are

Catch the most specific exception

If your code needs to recover from some exceptions, make sure to catch only those exceptions. If you catch more general ones, it's more likely you'll mistakenly swallow exceptions you don't want to swallow.

Only swallow if you're sure

This is really a corollary of the previous guideline. When you swallow an exception, your saying that you understand all cases where this exception could arise, and that the recovery code you're writing handles all of those cases.

Use lock or using if applicable

If you can use the lock or using statements, use them. They make the code more readable and make it more likely you'll do the right thing.

Wrap exceptions if applicable

If you can add additional information to an exception, by all means do so. If I pass a parameter on to another function, it might be useful for me to add additional information about the parameter.

The first two here are obviously directly applicable to the scenario, and would have at least raised some flags if I had first checked all the IOExceptions to see what they encompass.  The solution for me was to take a look at the pattern and reduce the scope of the IOException catches to only those statements that I expected might throw the exception for locking.

[UPDATE] I wanted to note that the exception handling pattern worked great until it was extended by me to a more complicated scenario involving dynamic assembly loading.

Today is my mom's birthday!  Yeah!  I know I usually post a picture of my birthday subjects, but I know she would be mad at me.

Happy Birthday!  Thanks for the many years of support you've given for me to take apart our appliances, make our electricity bill high with tons of electronics in my room, and risk the wrath of Child Protective Services by letting me sleep on the floor, in the closet, in the attic, in the camper, outside on the ground, in a tree, on the roof, in a hammock, etc.

I've been a proponent of DLP over other display technologies like CRT, plasma, and LCD (direct view and projection) for a while.  I've gotten to the point where I can somewhat easily tell the technology from a glance at the screen alone. All the current technologies have distinguishing characteristics:

• CRT
  • Direct view - The screen is obviously the front of a CRT
  • Rear Projection - The image is more fuzzy and floor models usually have horrible convergence issues
• Plasma - Beautiful, bright image.  Super thin
• DLP - Beautiful bright image, but rainbow effect if you shake your eyeballs really fast on high-contrast images (caused by the color wheel)
• LCD
  • Direct View - Thin, but not as thin as plasma, and duller than plasma.  Backlit
  • Rear projection - No convergence issues, no rainbow effect, not as bright as DLP

I was browsing in Best Buy the other day and ran into a JVC set whose technology I could not place.  It was obviously rear-projection and it was as beautiful and bright as DLP and plasma, but had no rainbow effect.  I was stumped.  I felt better when I examined it further and found it was a technology I was not familiar with.  It was HD-ILA.  It's based on what they call a direct-drive image light amplifier chip.  It's a reflective technology like DLP, but they use a 3-color process rather than a color wheel, which explains the missing rainbow effect.  It also has a price that's comparable to the DLP sets. Obviously, you could acheive the same results with 3 DLP chips, but at a higher cost.  A further benefit is that they can pack the pixels' reflective surfaces closer together, so more of the lamp light is reflected, so the image can be brighter.

There are a few things I'm still trying to figure out.  They are only using one lamp for all three colors, which may be possible as a result of using the lamp's brightness more efficiently, but I'd still like to break one open and take a look.  JVC's presentations don't have a picture of the insides.  From the presentation, it sounds like they are not using hinges, but perhaps controlling the reflective properties of the pixels themselves to turn pixels on and off. I'm still learning about the technology, but it seems this new player may be the way to go on a new set, which may be closer than I would like, given the problems I've been having with my old Toshiba set lately.

[UPDATE 1:42pm] The technology behind this is LCOS, which is a variant of LCD that has evidently become more manufacturable recently. So, the RGB sub-pixels are on the surface itself and a single lamp simply reflects off of the surface and is focused onto the screen.  This means it avoids convergence issues entirely, which was a concern of mine.  Another perk is that, if the subpixels are aligned the same as LCD, ClearType should work with this technology.

[UPDATE 1:57pm] Here's a review of the set I saw.  Pretty good and fairly humorous.

[UDPATE 1/5/2005 12:19pm] After some more reviews and research, it appears that JVC's D-ILA implementation of LCOS uses three chips, and I would think that eliminates my excitement about ClearType and a convergence problem free set. I'd still like to see the physical configuration. Most reviews recommend it, but the numbers seem to indicate that the current line is targetted at the average consumer rather than at videophiles (super-bright, high black levels, etc).  Unfortunately, I always would like videophile performance at average consumer budget.

I've been off for vacation for a little while, and today I went in for my first day of the new year.  I had been suspicious about whether today was one of the official holidays on the calendar, but I went in anyway.  Hardly anyone was there, and I related my suspicions to my boss, who went and got a new 2005 calendar and confirmed that it was indeed a holiday.  So, we went home.

Luckily, I won't have to spend time tomorrow catching up on my email and such since I did it all this morning.

We spent the day in Belton today with my folks and my brother.  We had a good time winding up the holiday festivities.  Mom made her patented roast, which she will tell you is nothing special, but it's really yummy.

Dave got an XBox communicator, and when Becky and I got back from Belton, I had about 5 hilarious XBox Live voice messages from him. We played several games of Halo 2 “Big Team Battle”.  I think you probably have to experience it to truly understand how fun it is, but it's an 8-on-8 team battle playing different kinds of capture-the-flag-esque games in huge environments with all kinds of flying, rolling, and hovering vehicles; lots of guns and grenades; and in-game voice hilarity.  The funnest moment for me was jumping in a Warthog (a humvee-type vehicle), waiting for Dave and another guy to jump in the passenger and gunner seats, and then taking off across the battlefield at full speed to pick up the bomb and singing pirate chanties along the way.  It was great.

I just checked my CallVantage account management page and found they had added alot of features! Most for free! One premium feature, which I don't mind spending an extra couple of bucks a month for is call filtering.  Now I can completely block those dang Austin American Statesman and SBC calls.

I just played my first online Halo 2 game.  WICKED AWESOME!!!  Check out my stats for the game. The medals are interesting. I'm also pretty proud of my hits. The game viewer is awesome although I can't seem to make a link for it since it opens via some javascript. At least I didn't lose.

If anyone's interested, here's my Halo 2 games RSS feed.

I'm gonna jump on and play some more!

We had a great time today with Becky's family. I finally got Halo 2 and have been playing the campaign mode since I can't get online yet.  It's by leaps and bounds the most beatiful console game I've ever seen.  All the cinematic sequences appear to be rendered in real-time and look as good as pre-rendered sequences.  Very impressive.

Becky and I have spent the last few days here in El Paso for some of our Christmas vacation.  I took some time to clean my father-in-law's pc from the many viruses and spyware programs that were grinding it to a halt.  It only had 64MB of RAM, which I upgraded to 384 using some old RAM that I happened to have in one of my bags. In the process of cleaning, I upgraded his AOL software to the 9.0 “security edition“ which comes with anti-spyware and anti-virus software, which was actually pretty nice.

Anyway, it's working great now and we're having a great time. I always realize how much I miss broadband when I'm here. Just googling something is such a huge ordeal. It snowed quite a bit yesterday evening, but the ground's still pretty warm so it's almost all gone now.

After tomorrow, I'm off for the rest of the year.  I'll likely be playing my fair share of video games.  I'd like to increase my XBox Live friends list so I can play online and actually feel some connection to the people I'm playing with.  So:

• Who's got XBox Live and what's your gamertag? Mine is, appropriately, “marklio” (I know it's lame, but I like consistency).  Feel free to leave yours here, or just send me a friend invitation (they really should have called that “friendvitation“).
• What are you playing? I should have Halo 2 by Christmas, but I'm looking for other cool online games.  I rented Star Wars Battlefront, which is pretty fun.

I've been using the MSN Desktop Search (I'll refer to it as that since I have no use for the rest of the toolbar suite and immediately turned it off) for the past few days and it is good enough to make me uninstall Google Desktop Search.  The fact that it, by default, indexes source code, xml and anything I can write an IFilter for was enough for me.  I also like the search as you type.  Very well done.

The only problem I have is it seems to conflict with WindowBlinds, software that lets me load thousands of visual themes for windows.  I have to unload WindowBlinds, search for something, and load it back up again.  Then everything works fine.  I suspect it has to do with the order that applications register hooks (which has caused problems like this before).

I picked up the component cables for the XBox last night (they're different than the ones in that link.  It looks more like the Monster Cable version).  I must say, they are the highest quality first party component cables for a video game system I've ever seen.  They also add the digital optical audio output.  For only $20, there's no need to waste a colossal amount of money on the Monster Cable ones. 

There's nothing like shooting Jar-Jar Binks with a sniper rifle in HD widescreen 5.1 Dolby Digital goodness.

I've also updated my holiday wishlist accordingly.

[UPDATE:12/16/2004]  I took the box over to Dave's last night where we romped on Jar Jar for a couple of hours.  He's got a direct view CRT which is inherently sharper than my rear projection CRT and it is definitely quite beautiful.  Can't wait to get Halo 2.

Today is the birthday of my good friend Jason Owens. Happy Birthday!  This is a picture from last Christmas. I miss the old birthdays where we'd all go spend the night at your house and play slaughterball and watch The Three Amigos.

Happy Birthday!

If you're interested in photography, you might be interested in the comments that Jerry left on my wishlist entry, especially if you've got a Canon Digital Rebel.

Jerry, I think the stabilization will help with my indoor problems.  I'm sure you know the situation I mean.  The light is just perfect on a sleeping cat, so you don't want to destroy it with a flash, but you can't capture it at a low ISO setting without camera shake and the tri/mono-pod would take too long to find/attach/adjust before the cat wakes up and ruins everything.  So I think the longer range becomes more important.  I enjoyed your lens quite a bit, so I think that's the one I'm going to aim for.  Besides, at wider angles, the low light problems become less prevalent.

BTW, I picked up the battery grip very soon after playing with yours this summer.  I love that thing.

I think you made a copy/paste error on your sweet bag url in your comments.  What was it?  I couldn't find it in the short time I searched. I'm going to add that too.

I've updated my wishlist accordingly.

I recently began putting just about everything, especially at work, into a revision control repository.  I find that I feel much more comfortable toying with changes in a presentation or document if I know I can easily get the previous version of it.  I noticed Martin Fowler seems to be headed in the same direction and has come to the same conclusions I have about revision control support in applications.  For instance, right now it's very difficult to tell the difference between two version of a presentation.

I noticed the latest version of FxCop has an option to save the file in a format that is friendly for version control.  Perhaps the new XML-based office formats will give us similar capability?

[Update 12:35] I forgot to mention Subversion, without which, the above would be very painful.  I'd also be interested in other people's revision control story.  How much has it seeped into your computing life beyond coding?

It's here!  My 2004 holiday wishlist.  First off, I don't post this to be greedy, I just think it's a handy way to let people know what kinds of things I'm interested in, let ME figure out what I'm interested in, and give me a future insight into what I thought was cool at this point.  Some of this stuff is way outside of what I would consider as typical “gift price range”, and I would never expect to get it.  I'll probably continue to update this as the holidays progress and I invariably cave in and get some things for myself or see something new and cool.  I'm going to categorize from the beginning since that's the way last year's turned out.

If, for some crazy reason, you're interested in actually getting me something, you might let Becky know in order to avoid duplicates (rebecky at dontspam mail dawt com).  I looked at several online wishlist sites to avoid that problem, but I didn't like any of them.  Any suggestions?

Video Game Stuff:

• XBox Console - It's finally on my list.  I'll probably take care of this one myself. Got it with the help of some used games
• Additional XBox Controller - This controller situation on the XBox is unclear to me.  There seems to be several official styles.  Which one is better?  Dave relates his distaste for them in the comments of a recent post.  What's the deal here? Evidently, the “S” controllers (that linked to) are the good ones according to the people I've talked to, and the consoles come with them now as opposed to old stupid ones.  Thanks Ben!
• HD cables for the XBox - I don't have any non-component sources hooked into my TV now (5 total now).  Why stop? I was just getting really tired of composite.
• XBox Live Starter Kit (w/ headset) - This is much cheaper than I thought it was. I've got 4-months XBox live free, and already picked up 1 communicator (Although I could use another)
• Halo 2 - The reason for the above Thanks, Rich!
• Any other recommendations for XBox stuff?

Computer stuff

• new keyboard and mouse with fingerprint reader - I've got a super old one on the coffee table now.  My wife will attest to that.  Fingerprints are cool.
• Pixma iP5000 Printer - It got the best reviews I've seen for a high quality photo printer.

Photography

• Canon Zoom Wide Angle-Telephoto EF 28-135mm f/3.5-5.6 IS Image Stabilizer USM Autofocus Lens - I've settled on this one after some insightful feedback from Jerry (see comments).
• Sweet camera bag - This one's really cool, and not really that expensive. 
• Any other sweet digital photography gear I should be wanting?

Home Theater

• Component Video/Audio switch - As I mentioned before, I'm out of inputs.  I have an older version of this that only does video.  This one does audio (optical/coax/stereo) as well and is auto-sensing!  Very cool.

Movies (DVD)

• The Bourne Identity Thanks Andy!
• The Bourne Supremacy
• Shrek 2

Clothes:

• Coming soon.

Gadgets:

• Green Laser - Jerry brought his by a few weeks ago and we had TONS of fun with it ... so bright.
• Phidgets - I found these on Scott Hanselman's list.  Way cool!  I can think of some cool stuff I'd like to do with the RFID stuff.  I wish they had stepper motor controllers.  I might finally finish my electronic pan/tilt head.

More to come!  I'm out of time for now.

Feel free to post YOUR wishlist items in the comments.

Well, it seems that the XBox finally has enough good games for me to want one.  Specifically Halo 2.  It's nice to see a console with a well-defined online strategy, even if I don't like it.

I've been thinking about this year's holiday wishlist, and I think it's going to have to include an XBox and Halo 2.  I've just been so dissapointed by the buggy online offerings from Sony and the non-existent ones from Nintendo.

I HAVE been enjoying the single player experience on PS2 and GameCube.  Metriod Prime 2 is an incredible sequel, Burnout 3 (PS2) is a blast (even though online is buggy as heck with zero support), and Paper Mario is just plain entertaining.

Look for my wishlist soon.

For the second year, I deep-fried a turkey for Thanksgiving.  Altogether, I think this was my 4th time, and this was by far the best experience. Here's some links to my past experiences.

The changes I made this time were:

• I let the turkey warm up a bit.  This kept the condensation from occurring so rapidly and therefore there was less popping when the turkey went in.
• I turned the turkey upside down (legs up).  This was suggested by several friends.  This reduced the “volcano effect“ of the hot oil through the body cavity.  It also kept the breast meat more uniformly in the oil.
• I made my own injectable marinades.  I usually just buy something premade.  This year I made a butter and herb marinade, as well as a Chipotle Tabasco marinade.  I've always done a half-and half, one side more exotic than the other.  Both turned out well.

Anyway, it turned out great.

Becky's parents and her brother Andy came down and we all drove up to Belton to have Thanksgiving “late-lunch” with my parents, brother and sister-in-law.  Everything was great.

[UPDATE] fixed spelling of volcano

Today is my little brother's birthday!  Happy birthday Andrew!

OK, I was not prepared for the onslaught of hilarity that ensued in the comments of my last post.  Somehow I think it's not over yet.  It's good to know that even though there are alot of us Mark Millers, that most of us seem to have a good sense of humor.

I about fell out of my chair at the thought of someone stirring a butter knife around in the trash to make it a more damaging weapon.  I think I'll have to use that in a movie.

For a split second, I was baffled at Scott Hanselman's recent post which claimed I had been working with him on some documentation tools.  Then I realized that, of course, this was a different Mark Miller.  This was not the first time I've been frustrated by the seemingly large number of Mark Miller's, especially in the blogosphere.

The real question is how can I distinguish myself from the others?  Certainly not by continuing to post rather bland entries to my blog.  I'm not able to make my work blog public (which is what I'd like to do), where there's alot of nifty activity.  I guess I just need to make a more concentrated effort to get my thoughts out in the open without revealing the application of the thoughts.  This probably could have a nice side-effect of thinking a little more abstractly about the decisions I make and maybe see a more broad application than I originally had in mind that make make a design work better.

Also, why WASN'T I working with Scott on some project? Why aren't I connecting with others more? That's a problem.

So, stay tuned, i guess.

I finally got Subversion set up over SSL hosted by Apache side by side with IIS.  The biggest problem was getting IIS to let go of port 443.  I'm running XP Pro SP2 and I'm not hosting any SSL from IIS, but it would still bind to port 443.  I found lots of information on configuring HTTP.SYS using httpcfg.exe (There's lots of other very cool SP2 tools in the download), which I though was really cool, but nothing that kept it from binding to 443.

My rather rudimentary solution was to start Apache first.  IIS/HTTP.SYS didn't complain about the port already being bound to.  It works like a charm now.  Now I can get to my repository from work through the firewall!  What I don't know is if the sequence of events at boot time will keep it from working right.  Any ideas?

I'm wondering how hard it would be to write a Subversion server on HTTP.SYS.  Now THAT would be cool!  I think it would only be a matter of implementing (or finding an implementation of) WebDAV and hooking into the Subversion API.

I am not a morning person.  Anyone who's ever spent any time with me in the morning knows that.  I've been tracking my productivity more closely lately (in terms of tangible, work-related results anyway), and I've found that I am far more productive after lunch than I am before lunch.  This doesn't mean I don't do anything in the morning, I just don't seem to have the same kinds of satisfaction with how I've spent my time.

I originally thought that I was being productive in a different way in the morning.  For instance, in the late afternoon and evening, I enter a fairly reflective state.  In this state, I question the design decisions I've made or the implementation I've chosen.  This is when I do alot of measurement in the form of tests or profiling.  That's plenty productive and useful activity, but in a different way.  I thought maybe the morning was perhaps an analogous, forward-looking phase, readying me for the tangible productivity ahead.  But, no, I'm just not very productive in the morning.

I'd like to find some activity or state of mind I could concentrate on in the morning in order to accomplish more in the morning.  Any ideas?  Does anyone else feel like their mind is more dormant at points during the day?  What do you do about it?

This morning I looked up my voting location and found it to be less than 100 yards from my house!  It was quite convenient and I had voted in a matter of minutes after a short walk down to the community center.  I'm glad I was in town today and wasn't forced to wait in a long line for the convenience of early voting.

I though this article was appropriate for today.

I hate the fall time change.  When I was young, I was always was fooled into liking it because I got an extra hour of sleep.  Now I know it's just a trick to take one hour of daylight from the end of the day.  I can get an extra hour of sleep pretty much whenever I want by going to bed earlier. I'd much rather drive to work in the dark than come home in the dark.  It makes me just want to go to bed when I get home, and it doesn't really help me wake up any earlier.

I'm glad I got dasBlog fixed in time to blog about Google Desktop.  Trust me, if you ever have looked for something on your hard drive or in your email, you want it.  It is freaking awesome!  I saw a video demo of the new MSN search which is identical in purpose, but it appears they've been beaten to the punch.

Scott Hanselman has some good observations on how it works.

Since the 64-bit windows versions can only run the 2.0 framework, everything is having to run on 2.0.  This is a good test for the framework.  DasBlog does not run as smoothly on the 2.0 beta framework as I hoped.  So far, it's been problems with client-side interaction with server-generated html (javascript).  For example, the sign-in code had some nifty javascript that was formed in a fairly short-sighted way. I had to change the way that controls were being referenced.

I'm also having trouble getting apache installed to run Subversion.  I may have to make due with svnserve until I figure that out.

I just came across the Subversion Book. From the site:

a free book about Subversion, a new version control system designed to supplant CVS. As you may have guessed from the layout of this page. this book is published by O'Reilly Media.

At work we adopted Subversion and I really love it.  We made (in my opinion) a mistake early on by separating our projects into multiple repositories.  This makes it very difficult to handle the versioning synchronization when those projects collide.  It looks like the svn:externals property may keep us from  having to migrate to a single repository before we're ready to take on that problem.

As you can see, I've already taken away some useful tidbits.  A must read for anyone using Subversion.

This past week, Becky's PC finally had enough problems with it to warrant a new one.  I think the final problem was with the interupt controller.  Anyway, I always enjoy an excuse to put together a new one, and I felt this was as good an excuse as any to start experimenting with my Home Theater PC project.  It also will take over the role of serving this page, at least for a while.  The old server will become Becky's PC, and will be a welcome upgrade.

I decided to go 64-bit so I could get a head start looking at the migration path for .NET apps (which is extremely low friction (not even a need for recompiling in most cases)).  I ended up getting an AMD64 combo from Fry's with an MSI motherboard.  I've been more and more frustrated with Fry's recently.  The motherboard is pretty good, but mine seems to have a problem with the on-board ethernet.  You can wiggle the connection around and the link light will turn on and off, and the drivers seem to have trouble (the latest 64-bit nForce3 drivers) recognizing it and such.  So, I've got to exchange it this evening.  Seems like I have to go through that at least once for almost everything I get there.

Other than that, I'm very pleased with the performance.  Seriously fast.  When the POST screen is the bottleneck in the boot process, you know you've made a significant performance jump.  Hopefully, we'll be up on the new system soon.  I'm torn on whether to run XP or Server on it.  I'm going to be using it as a media center, so XP seems to be the route to take.  On the other hand, I'll be hosting some stuff on it as well, which makes Server the more appropriate route.  Any feedback?  I initially installed server and thought the network problems were driver issues with the platform.  So it's got XP on it now.

Today is my dad's birthday!  Happy Birthday, Daddio!

Along the same vein as my last entry.  I ran across A9.com this morning.  It's pretty spiffy.  I really like what they've done in terms of interface, all the way down to the URLs created from searching.  This is especially handy since most of my searches are generated by url generation.  It much simpler than reverse-engineering someone's form contents.  Definitely an idea worth applying to other things I'm working on.

For those of you who swear by Google, you can rest easy because the web and image searches are both powered by Google.

I haven't had a chance to fully digest it yet, but I hope there will be more sources of information we can add or customize.

A friend showed me Toogle today.  Pretty interesting spin on Google's image search.
homer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simp
sonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+s
impsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhome
r+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonh
omer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simps
onhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+si
mpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer
+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonho
mer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpso
nhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+sim
psonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+
simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhom
er+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpson
homer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simp
sonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+s
impsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhome
r+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonh
omer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simps
onhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+si
mpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer
+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonho
mer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpso
nhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+sim
psonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+
simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhom
er+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpson
homer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simp
sonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+s
impsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhome
r+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonh
omer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simps
onhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+si
mpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer
+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonho
mer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpso
nhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+sim
psonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+
simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhom
er+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpson
homer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simp
sonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+s
impsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhome
r+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonh
omer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simps
onhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+si
mpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer
+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonho
mer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpso
nhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+sim
psonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+
simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhom
er+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpson
homer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simp
sonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+s
impsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhome
r+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonh
omer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simps
onhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+si
mpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer
+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonho
mer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpso
nhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+sim
psonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+
simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhom
er+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpson
homer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simp
sonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+s
impsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhome
r+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonh
omer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simps
onhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+si
mpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer
+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonho
mer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpso
nhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+sim
psonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+
simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhom
er+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpson
homer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simp
sonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+s
impsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhome
r+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonh
omer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simps
onhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+si
mpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer
+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonho
mer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpso
nhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+simpsonhomer+sim