Michael Haren

Easter Eggs in Red-Gate’s SQL Compare

2010-03-11T13:43:00.001-05:00

A coworker discovered a neat Easter egg in Red-Gate’s Schema Compare for Oracle: Oracleoids:

I checked the tools I use and discovered this Easter egg in SQL Compare and Data Compare (v7.1):

Which, after a few seconds, turns into one of those annoying slider puzzles:

Fun stuff!

Watch out for that Distribution Database

2010-03-11T11:38:00.001-05:00

I received some pretty serious alerts this morning about our database server running low on disk space and quickly discovered something amiss:

That’s a tad higher than usual…just 100x bigger than it should be (yikes)! Allow me to illustrate how I imagine the last few months going for this gargantuan file:

The problem turned out to be that several of the replication SQL jobs were disabled (since…months ago). The pertinent job is probably this one, the distribution clean up job:

It’s supposed to run every 10 minutes to tidy things up in the distribution database. I guess not running for three months could lead to some problems (eek!). There’s really no excuse for this—it’s embarrassing. I’m not the DBA for this system but I should have noticed; a lot of people should have noticed.

Since this task was disabled (not failing), it didn’t show up in our usual alert stream. I’m not sure how we solve that problem other than create an alert that detects disabled jobs. Or better yet, we could create alerts that fire whenever the job hasn’t run in the last n minutes—something like that.

Of course adding more sensitive alerts to the sizes of certain files or the free space of certain drives will help, too.

So I guess the lesson here is to run regular checkups on your critical infrastructure and leverage monitoring services if you can to make the checkups easier and more effective.

Autohotkey: Wrapping the selection with a tag

2010-03-10T12:42:00.001-05:00

Autohotkey is a nice tool to be familiar with—it enables you to create advanced hotkeys. Today, I built a very simple script which saved me a bunch of time. Here’s the skinny:

I’ve been blogging about software a lot and these posts are often heavy with terms or phrases that I wrap in http://www.autohotkey.com/ tags. Unfortunately, my editor (Live Writer), as awesome as it is, doesn’t support something like this. AutoHotKey to the rescue!

Here’s the script:

#c::                       ; fire on WIN+c
AutoTrim Off               ; Retain any leading and trailing whitespace on the clipboard.
ClipSaved := ClipboardAll  ; Save the entire clipboard so we can restore it when we're done
SendInput ^x               ; cut the selection to the clipboard
ClipWait                   ; wait for the clipboard to contain something
SendInput <code>%clipboard%</code> ; Output what was selected, surrounded by <code> tags
Clipboard := ClipSaved     ; Restore the original clipboard
ClipSaved =                ; Free the memory in case the clipboard was very large.
return

Load this into your AHK script, hit reload, and fire away. Select some text, hit WIN+C, and watch in amazement as it is surrounded by <code> tags.

Building URLs for “SRC” Attributes in ASP.NET MVC

2010-03-10T12:01:00.001-05:00

I’ve been told that these programming posts are not interesting or funny. For those that have no interest in programming, I offer the following jokes:

“Chuck Norris can divide by zero”

“Chuck Norris can touch MC Hammer”

“Chuck Norris CAN believe it's not butter.”

–Chuck Norris Facts

Now would be a good time for you to stop reading.

Dive into ASP.NET MVC and it won’t be long before you do this in a master page:

    <link type="text/css" rel="Stylesheet" href="~/Content/all-src.min.css" />
    <script type="text/javascript" src="~/Scripts/all-src.min.js"></script>

This of course includes a couple global files—one for styles and one for scripts. Here’s the rub: it doesn’t work at all. It’ll seem like it works at first, because you’ll have nice styles and some of your scripts might even work, but it will be a short-lived experience.

Unfortunately something funny is going on here. Those URLs are not valid—they’re more than relative (relative URLs are fine), they’re relative from an application root, denoted by the tilde (~). That tilde means nothing to the browser.

Now the funny business is that ASP.NET will rewrite the link tag automatically to include the correct relative URL by replacing the “~” with the appropriate path. It does not do that with script tags. So you try to be clever and use a web-friendly relative URL syntax like this:

    <script type="text/javascript" src="../../Scripts/all-src.min.js"></script>

Sorry, that doesn’t cut it. The “../../” will only work properly if the content page (which uses the master page) is nested 2-levels deep, which is not likely to be true very often.

The trick is to call into Url.Content or Url.Content like so:

    <script type="text/javascript" src="<%=Url.Content("~/Scripts/all-src.min.js")%>"></script>

This extra step will give me a nice URL, regardless of the page’s depth in my tree. So what’s the difference between Url.Content and Url.Content? ResolveUrl has been around forever as part of Url.Content. On the other hand, Url.Content is relatively new and ships as part of Url.Content. Aside from that, I have no idea—if you do, please share.

Note: these commands work pretty much everywhere—imgs, Url.Content, etc.

+/-20 Years of Computing

2010-03-08T15:20:00.001-05:00

In less than 140 characters:

Great new things by decade: 90s: make/save data; 00s: find data; 10s: visualize data, extract greater meaning; 20s: democratize data

In detail:

1990s

The 90s were an incredible time. This was the decade where most computing focused on generating data and saving it. The conventional wisdom of the day seemed to be that, through a magical process, massive amounts of data could be used to solve anything. This was the era of the chess playing super computer, Deep Blue. This was the “anything is possible” childhood of the Internet.

2000s

Then came Google. Google made the 2000s the year of search. By then, what it had started in 1998 had reach a seriously huge critical mass. Early in the decade, though, many people and companies struggled to understand the Internet. This was a scary time for me as I saw some high profile collapses like Pets.com learn some hard lessons in business fundamentals (e.g. 1,000,000 views * $0/view = $0).

It’s during this time that businesses based on good foundations of revenue and purpose really grew. This was the decade of search. Entire generations learned that by typing a few keywords into a box could lead you to damn near anything you wanted to know. Organizations and aspiring individuals learned that by pushing information to the Internet in a public way, they could capitalize on this traffic. This was a cool decade.

That brings us to today.

2010s

We’re starting to feel a little overloaded by the massive amounts of information available to us. The ability to find a dataset, track it over a period of time and compare it to another dataset is a fairly challenging task today. This is where I expect to see some big “Wows” in 2010—visualization of data.

I’ve seen some absolutely amazing things coming from TED lately (go watch those now) and am excited for what fiscally strong companies and universities can create. Enabling non-PhDs to extract meaning and value out of massive amounts of data has been on the radar for the last 20 years—I think we’re finally to a point where it can happen on a grand scale.

Computing power is no longer a limitation.

Connectivity is no longer a limitation.

We will seem some very impressive and innovative ways to make sense and meaning of data very soon.

2020s

I think the success of data visualization will lead to passionate movements to democratize data. Around 2020, it will no longer be acceptable to conceal, hide, or privatize data. There will be a very successful movement to make government data and university data available via extremely accessible means—via APIs or methods that probably don’t exist today. Individuals will adopt the use of standards and contribute—for free—to the pool of data. This long-tail effect will be interesting if not incredible.

Organizations will jump on board and contribute to this stream by dropping the unsuccessful pay-walls they constructed in the 2010s. Vague patents, which will be distorted and abused in the 2010s to monetize data will be invalidated or expire and the flood gates will open.

In 2028, people will start discussing the merits of a conventional census—a reinvigoration of arguments made leading up to the 2020 census. Doing away with the census—which seemed ridiculous in 2018—will have a lot of support. We’ll do one anyway (at great expense) but it’ll be the last time. Around this time (2030), near-real-time data of greater quality than today’s census numbers will be available to all of us.

In Summary

I’m excited.

Thanks to the Internet, I’ll end up back on some future incarnation of this page to see how completely and utterly wrong I was about everything (I can’t wait).

Creating/Submitting a Patch to a Subversion Repo

2010-03-08T13:38:00.001-05:00

I’ve been told that these programming posts are not interesting or funny. For those that have no interest in programming, I offer the following jokes:

“I don't think I could stab somebody, cause I'm really bad at a Capri Sun.”

“I hope God speaks English. If I get up to heaven and have to point at a menu, I'm gonna be pissed.”

“I hope we find a cure for every major disease, because I'm tired of walking 5K. I'm pretty sure I don't have to sweat for cancer. I'll write a check.”

–Daniel Tosh (via)

Now would be a good time for you to stop reading.

I use Subversion as my primary version control system. It’s awesome. I have a few users that have read-only rights to this repo and only occasionally make changes themselves. In these cases, I can’t provide commit rights to the repo so what are we to do? Patches.

A patch is basically a change set wrapped up into a single tidy file. The patch can be created by one dev and sent to another to be applied to the VCS. SVN, like most VCSs has very good support for patches. This post describes how to create one.

First, you should update your working directory if possible with “SVN Update”:

Normally you would go to the Commit screen to apply your changes. Since you don’t have commit access, this won’t work, so instead right-click and go to “TortoiseSVN” > “Create Patch”:

A dialog will show you all the changes it has detected; you can double click each file to diff it. Choose the changes you want included in the patch and click “OK”:

Save the patch somewhere handy:

Send the patch file off to your committer and you’re done! Go ahead and open it up in a text editor if you want to see how these work. It’s basically a snippet of each of the pieces of code you changed, all bundled up into a nice text file.

Applying a Patch to a Subversion Repo

Of course the process of applying patches is simple, too. Right-click on the patch file and choose “TortoiseSVN” > “Apply Patch”:

Choose the SVN working directory to which the patch should be applied:

You’ll see a list of the patched files and have the opportunity to review each change:

Then right click to apply some or all of the changes into the working directory you chose.

The patch has now been applied to your working directory—now would be a good time to commit it via normal means (right-click > “SVN Commit”):

It might seem a little complicated at first, but after you do it once or twice it’ll click as a convenient and effective way to share change sets.

Active Directory Look-Up

2010-03-05T18:08:00.001-05:00

I’ve been told that these programming posts are not interesting or funny. For those that have no interest in programming, I offer the following joke:

“I was gonna get a candy bar; the button I was supposed to push was ‘HH’, so I went to the side, I found the ‘H’ button, I pushed it twice. F’in...potato chips came out, man, because they had an ‘HH’ button for Christ's sake! You need to let me know. I'm not familiar with the concept of ‘HH’. I did not learn my AA-BB-CC's. God god, dammit dammit” –Mitch Hedberg (via)

Now would be a good time for you to stop reading.

I’ve been working on an app that’s defers authentication to the company’s Active Directory. Rather than ask user’s to fill in profile info like a display name, I decided to pull this info out of the directory.

This turned out to be ridiculously easy after adding a reference to System.DirectoryServices.AccountManagement to the project:

using (var PC = new PrincipalContext(ContextType.Domain))
{
    var UserPrincipal = Principal.FindByIdentity(PC, userName);
}

In this case, we’re passing along the user’s NT name, including the domain to help make it unique (e.g. “domain\user”) and getting back an object of type System.DirectoryServices.AccountManagement.Principal, which has some nice properties like DisplayName and Sid.

Since I’m running this app as a domain user, I don’t even have to configure the directory connection (which is nice, because that part’s a pain).

OK so I have the user’s name, but I’m rarely a fan of duplicating data. But I need a local copy of the user’s name to keep things nice and speedy (plus hitting the domain for a person’s name all the time is a little silly, too).

My compromise is that I update my local copy with the directory’s profile data each time the user logs in. I’m already hitting the domain to authenticate the user any way so it’s not any extra work. This should take care of the rare situation that someone’s name or profile info changes without requiring anyone to do anything.

HTML/JS: Progressive Enhancement

2010-03-05T11:59:00.001-05:00

The great thing about a semantic approach to web development is how nice and easy it can be to make progressive enhancements.

For example, suppose I have a “what’s this” help link beside some potentially confusing statement:

Nothing fancy here—just a link with a _blank target (source, demo):

<p>Hello World 
  <a href="/help/tips"
     target="_blank" 
     title="Hello World Help"
     class="help-link">(what's this?)</a></p>

It’s not very pretty but it gets the job done without any Javascript. Let’s make it sexy:

Here we’ve augmented the help link with a nice jQuery UI dialog instead of a browser popup (source, demo):

$(function(){
  
  $('.help-link').click(function(){
    
    $('<div></div>')
      .attr('title', this.title)
      .load(this.href)
      .dialog({
        modal: true,
        buttons: {
          Ok: function () {
            $(this).dialog('close');
          }
        },
        width: 600,
        height: 350    
      });
    
    return false;
  });
  
});

This doesn’t require any changes to the HTML/CSS—it uses existing attributes like href and title to wire itself up to the link. And, if JS is disabled or broken, the link will still work.

By applying incremental enhancements in this fashion, we can easily maintain decent support for less-capable browsers while keeping our code clean and elegant.

You might notice, too, that this JS snippet is looking at a class (help-link), not an id. Since it infers everything it needs to show the dialog from the link itself, this snippet will work on any link in the page tagged with the help-link class. Nice, right?

Generating Super Shiny, Hopefully Secure Tokens

2010-03-04T23:06:00.001-05:00

I’ve been told that these programming posts are not interesting or funny. For those that have no interest in programming, I offer the following joke:

“My friend had a burrito. The next day he said, ‘That burrito did not agree with me.’ I was like, ‘Was the disagreement over whether or not you’d have diarrhea? Let me guess who won.’” –Demetri Martin (via)

Now would be a good time for you to stop reading.

I was working on a little security related code today which required the generation of unique and random tokens. I’m always nervous working with crypto because it’s so easy to fail.

But here I am, ready to fail.

So like I said, I need to create a bunch of tokens—blocks of text or numbers. They can’t be easily guessed and need to be unique. Let’s see if I can’t screw this up.

        /// <summary>
        /// Generate a decently long string o random characters, suitable for tokens
        /// </summary>
        /// <returns>a string of gobbledygook</returns>
        public static string GenerateKey()
        {
            var RandomBytes = new byte[
                6 * 10 // use a multiple of 6 to get a full base64 output http://en.wikipedia.org/wiki/Base64
                - 16 // compensate for the 16-byte guid we're going to add in 
                ];

            // fill the buffer with garbage (this is threadsafe)
            BetterRandom.GetBytes(RandomBytes);

            // get a guid, which will be unique enough for us
            var UniqueBytes = Guid.NewGuid().ToByteArray();

            // encode the garbage as friendly, printable characters
            var AllBytes = new byte[RandomBytes.Length + UniqueBytes.Length];
            UniqueBytes.CopyTo(AllBytes, 0);
            RandomBytes.CopyTo(AllBytes, UniqueBytes.Length);

            return Convert.ToBase64String(AllBytes);
        }
        static RandomNumberGenerator BetterRandom = new RNGCryptoServiceProvider();

Basically I take two components—a 16-bit GUID, and a 44-byte chunk of random bits. The GUID would normally be enough to satisfy me as they are pretty much unique (and the Win32 algorithm might even guarantee them to be unique when considering a single machine) but, I was afraid they might be predictable as they aren’t actually all that random.

How’d I come up with 44 bytes (352 bits)? It looks nice. I guessed a few numbers until I got the encoded output to be of reasonable size. Which brings me to the Base64 conversion. This just takes the binary blob of bits and turns them into simple, printable characters so I can pass them around in URLs.

If you’re know of any weaknesses with this approach, please share! Something like this will eventually guard something about as valuable as a garden gnome, so I’m not too worried about it yet. It’s certainly more secure than the simple passwords most of us use.

Class Inheritance Throw Back

2010-03-04T15:11:00.001-05:00

Another question I answered recently took me way back to my college classes on programming language theory. In those classes we studied the internals of languages in greater detail than I’d care to remember. We also build a Scheme scanner, parser, printer, too, which was fun.

Anyway, the question today was: given a base class “Animal” and a derived class “Dog”, in what order are the constructors and destructors called when the child class is instantiated and destroyed?

I haven’t touched C++ for a long time but after thinking about it for a few seconds, this is what would make sense to me:

new Dog():

Animal()
Dog()

delete Dog():

Dog()
Animal()

The constructor part is the same in C# (my current language of choice) so that was obvious, but we don’t really have destructors in C# (we have IDisposable) so i had to think about that logically a bit.

The gist is: constructors are executed top down, and destructors are executed bottom up. I like digging into the details and the nuances of these things…

Algorithms Throw Back

2010-03-04T14:23:00.001-05:00

I was given a question today that really took me back. Here’s a hint: it had to do with binary search trees, data structures, and pretty printing.

I haven’t touched a BST in six years so it took some priming to get me going.

(BST builder)

The task was to print this tree level by level. So the output should be 3, 1, 6, 2, 5, 7, 4. If you’re a programmer, I encourage you to solve this problem as an exercise before looking at my solution. It was humbling for me.

After wasting a half hour messing around with recursion, I was given a pretty nice hint to do it iteratively with a queue.

I still failed miserably with my good old paper and pencil, but afterwards set out to do it in a more comfortable environment (C#).

Here’s my basic node class (structs are for sissys):

    public class Node
    {
        public Node(int value, Node left = null, Node right = null)
        {
            Value = value; Left = left; Right = right;
        }
        public int Value { get; set; }
        public Node Left { get; set; }
        public Node Right { get; set; }
    }

And my main program:

    static void Main(string[] args)
    {
        Node n = new Node(3);
        n.Left = new Node(1, null, new Node(2));
        n.Right = new Node(6, new Node(5, new Node(4)), new Node(7));

        PrettyPrintByLevel(n);
        Console.ReadKey();
    }

And the magic:

    static void PrettyPrintByLevel(Node n)
    {
        Queue<Node> Nodes = new Queue<Node>();
        Nodes.Enqueue(n);

        do
        {
            Node QNode = Nodes.Dequeue();
            Console.WriteLine(QNode.Value);

            if (QNode.Left != null) Nodes.Enqueue(QNode.Left);
            if (QNode.Right != null) Nodes.Enqueue(QNode.Right);

        } while (Nodes.Count > 0);
    }

A quick test reveals that it works:

3 1 6 2 5 7 4

Yay! So what did I learn today? I’m rusty on the basics and need to do some more Project Euler problems.

I’ve taken this opportunity to brush up on some Java. Here’s the same app in the similar, but different Java:

    public static void main(String[] args) {
        // build up a tree
        Node n = new Node(3, null, null);
        n.Left = new Node(1, null, new Node(2, null, null));
        n.Right = new Node(6, new Node(5, new Node(4, null, null), null), new Node(7, null, null));

        // print out the tree to the console
        PrettyPrintByLevel(n);
    }

    private static void PrettyPrintByLevel(Node n) {
        Queue<Node> Nodes = new LinkedList<Node>();
        Nodes.add(n);

        do
        {
            Node QNode = Nodes.remove();
            System.out.println(QNode.Value);

            if (QNode.Left != null) Nodes.add(QNode.Left);
            if (QNode.Right != null) Nodes.add(QNode.Right);

        } while (Nodes.peek() != null);        
        // process the queue until it's empty
        // peeking for a null element is certainly faster (or as fast) as
        // calling for the list's length over and over again
    }

It’s pretty much the same thing.

Word Document Automation with .NET 4: New Doc From Template

2010-03-02T22:41:00.001-05:00

With all the Word automation stuff I’ve been working through, it was nice to find something easy today. I wanted to create a base template and use it to start my docs from. So I created the template in Word as usual and saved it as a .dotx.

Then, to start new docs from this, just include it in the .Add() call:

WordApp = new Application();

// open the template as a new doc
var Doc = WordApp.Documents.Add(PathToTemplateFile);

Easy does it.

Leave SQL Server’s Cost Threshold for Parallelism Alone

2010-03-02T13:36:00.001-05:00

I’ve been told that these programming posts are not interesting or funny. For those that have no interest in programming, I offer the following joke:

“I like fruit baskets because it gives you the ability to mail someone a piece of fruit without appearing insane. Like, if someone just mailed you an apple you’d be like ‘Huh? What the hell is this?’, but if it’s in a fruit basket you’re like ‘This is nice!.’” –Demetri Martin (via)

Now would be a good time for you to stop reading.

A while back I was performance-testing a new SQL Server cluster. This machine was years-better than the system it was replacing and the perf-test was showing it. Everything I threw at it was flying—this thing was screaming fast.

Then we started load testing. This was basically an integration test where we turned on everything at once and cranked it to 11. Only we didn’t get to 11 because our server fell over at 2, making me a sad panda. The server started throwing strange and never-before-seen (by me) errors about problems with memory, threads, timeouts, etc. It looked like this:

We had barely loaded the machine with concurrency and it was freaking out. It’d run in spurts of blazing glory, then fail to a grinding halt. After a lot of personal freaking out (we had a very, very tight schedule measured in minutes), I discovered the culprit: parallelism.

Normally you would think parallelism would be a good thing—many cores make light work (this machine had 16!). Unfortunately that’s just not so in all cases. The overhead to split a query into parallel chunks, execute the chunks, and join the results together is significant. It turns out it’s extremely significant for simple queries and increases the complexity/load required to execute them dramatically.

Fortunately, SQL Server knows all this and has a setting for it:

The cost threshold for parallelism. This value is in seconds. When SQL Server estimates a query will take longer than x seconds to be executed, the query is executed in parallel; otherwise serial.

Do not set this to a very low value like my DBA apparently did.

Ruminations: Multiple Births; Congratulations

2010-03-01T18:39:00.001-05:00

I am afraid if I ever have twins or triplets that I would try to carry too many at one time and drop one, both, all, etc. Oops!

And that's my segway into my congratulations to B+T on their new double-dose of parenthood. Here's a list of things to keep you occupied during your downtime (infants are boring):

...you won't be having any of that. Sorry. Now let's extrapolate your family:

At this rate (if my calculations are correct), the trend is slightly alarming:

Of course the total number of kids you have will be a bit more dramatic:

The only thing I can conclude from this is that you might want to refocus your house-hunting for something in the country. With lots of room.

In any case, best of luck to you and enjoy these first few weeks as a family of five! Let me know if I can help in any way (I just might).

Moving List Items Between Lists

2010-03-01T16:11:00.001-05:00

I often apply a push-pull pattern when working with business/data interfaces. I’m talking about something like this:

I don’t much like these so I came up with something similar that works well for small datasets which I’ll describe here. Here it is in action:

and here’s how to build it. First, the basic layout:

<body>
  <ul id='list1'>
    <li>Item 1 <img class='icon move' src='blank.png'/></li>
    <li>Item 2 <img class='icon move' src='blank.png'/></li>
    <li>Item 3 <img class='icon move' src='blank.png'/></li>
    <li>Item 4 <img class='icon move' src='blank.png'/></li>
  </ul>
  <ul id='list2'>
    <li>Item 5 <img class='icon move' src='blank.png'/></li>
    <li>Item 6 <img class='icon move' src='blank.png'/></li>
    <li>Item 7 <img class='icon move' src='blank.png'/></li>
    <li>Item 8 <img class='icon move' src='blank.png'/></li>
  </ul>
  </body>
</html>

What I want to do is have each li hop to the opposing list when its move button is clicked. It’s very simple with jQuery’s live event binding (demo, source):

  $(function(){
    $('ul#list1 .move').live('click', function(){
      $(this).closest('li').appendTo('ul#list2');
    });
    
    $('ul#list2 .move').live('click', function(){
      $(this).closest('li').appendTo('ul#list1');
    });
  });

These events aren’t bound to the items themselves. Rather they sit higher up the DOM and, through some event delegation magic, are handled by any li matching the selector (including elements appended in the future). So when an li’s move icon is clicked, the event handler walks up the DOM until it finds the li element, and moves it to the other list via a call to appendTo(). This technique can be combined with jQuery UI’s sortable component, too, for drag/drop and reorder support, too.

It’s also really easy to add animation (demo, source):

  $(function(){
    $('ul#list1 .move').live('click', function(){
      $li = $(this).closest('li');
      $li.fadeOut('slow', function(){ $li.appendTo('ul#list2').fadeIn(); });
    });
    
    $('ul#list2 .move').live('click', function(){
      $li = $(this).closest('li');
      $li.fadeOut('slow', function(){ $li.appendTo('ul#list1').fadeIn(); });
    });
  });

Now we’re getting to the point where some refactoring might be appropriate (demo, source):

  $.fn.pushTo = function(toSelector)
  {
    $this = $(this);
    return $this.fadeOut('slow', function(){ $this.appendTo(toSelector).fadeIn(); });   
  };
  
  $(function(){
    $('ul#list1 .move').live('click', function(){
      $(this).closest('li').pushTo('ul#list2');
    });
    
    $('ul#list2 .move').live('click', function(){
      $(this).closest('li').pushTo('ul#list1');
    });
  });

It’s not really any less code, but we’ve moved the messy animation pieces out into a chainable function. I could have moved the .closest() pieces into the function, too, but that would make the pushTo() method a little too specific to this task for my taste. Since we have the animation isolated to one line, we can easily change it to slide the items in and out (demo, source):

  $.fn.pushTo = function(toSelector)
  {
    $this = $(this);
    $this.slideUp('slow', function(){ $this.appendTo(toSelector).slideDown(); });   
    return $this;
  };

Finally, if you use something like this in a real app, use ‘fast’ for the animation speed. I’m using ‘slow’ here to make it obvious. In practice, though, it’d be very annoying.

Word Document Automation with .NET 4: Attach Styles From a Template

2010-03-01T14:03:00.001-05:00

I’ve been working with document generation a bit lately. The latest hurdle I’ve had to jump is related to styles. I’ve found that the technique I’m using to merge styles is nice and easy but has one undesired feature: each source doc brings its own styles with it, overwriting any existing styles that have already been imported as it goes. This is nice in a lot of ways, but not what I want at the moment.

After a lot of trial and error, I’ve come up with a super simple way to apply a single set of styles to the finished document:

public static void StyleDocument(Document document, string templateFile)
{
    document.CopyStylesFromTemplate(templateFile);
}

That’s it! This will take all the styles from the given .dotx or .docx file and apply them to the given document object. If you only have a file path of the document that needs to be styled, you’ll need to open/close it, too, with this overload (in addition to the above method):

public static void StyleDocument(string file, string templateFile)
{
    Application WordApp = null;

    try
    {
        WordApp = new Application();
        var Document = WordApp.Documents.Open(file);
        StyleDocument(Document, templateFile);
    }
    finally
    {
        DisposeApp(WordApp);
    }
}

Where DisposeApp(…) is just a helper to cleanup my mess:

private static void DisposeApp(Application WordApp)
{
    if (WordApp != null)
    {
        foreach (var Doc in WordApp.Documents)
        {
            (Doc as _Document).Close();
        }
        (WordApp as _Application).Quit();

        System.Runtime.InteropServices.Marshal.FinalReleaseComObject(WordApp);
    }
}

This technique is far, far nicer than working with the styles manually.

How the Richter Scale Works

2010-02-28T23:35:00.001-05:00

I saw this headline:

Chile’s earthquake 500 times stronger yet less destructive than Haiti’s

and started wondering: how Chile’s quake could be 500x as powerful as Haiti’s when their respective Richter scale magnitudes are 8.8 vs. 7.0? The “less destructive” part is interesting, too, but everyone’s already talking about that so I’ll focus on the scale.

The first clue is that the scale is logarithmic. That means that each increment of 1 is a 10x increase in magnitude. If you were to plot x vs. log₁₀(x), it might look like this:

Well, that’s not very revealing until you realize that the x-axis is increasing logarithmically. Consider the same data but with the x-axis presented linearly:

Now we’re talking. Each increment on the y-axis is a 10x increment on the y-axis. i.e. 8 is 10x greater in magnitude than a 7:

10⁸/10⁷ = 10

So it follows then that an 8.8 (Chile) vs. 7.0 (Haiti) would be:

10^8.8/10⁷ = 63

Thus an 8.8 is 63 times greater in magnitude than a 7. Wow. OK so how do we get to 500x more destructive? It would seem that the news is using a different factor: energy. I didn’t dig into all the math behind it but the gist of it seems to be that while the Richter scale measures raw amplitude of the little pencil on the paper wheel/strip triggered by the earthquake's waves, the actual energy factor is much higher than 10:

Because of the logarithmic basis of the scale, each whole number increase in magnitude represents a tenfold increase in measured amplitude; in terms of energy, each whole number increase corresponds to an increase of about 31.6 times the amount of energy released.

So I guess the news people are applying this to the log scale with a base of 31.6 instead of 10. Let’s check:

31.6^8.8/31.7⁷ = 501

Hooray! I honestly didn’t know that would work until I got to this point and calculated it (phew!). So this makes me wonder how effective a scale is when it’s not…intuitive at all. Certainly a simple, scientific number is helpful, but I’m not sure this is the right number to use in casual conversation.

Instead, numbers related to life lost, people displaced, or damage are probably more relevant and appropriate to compare. For example, the current mortality estimates are: Chile 700, Haiti 220,000:

220000/700 = 314

The quake in Haiti has killed (to date) 314 times more people than the quake in Chile. (That article also explains the 500 figure pretty well—I should have read it before writing this post :P)

On a very related note, there’s a super cool Radio Lab podcast about numbers which explores the idea that we count logarithmically when born but learn to count absolutely as children. Neat.

Also of note: decibels—a measurement of sound intensity is in logarithmic units, too, as is pH in chemistry.

Finally, for tons of info on Earthquakes, checkout the USGS.

Why Twitter is Awesome

2010-02-27T19:04:00.001-05:00

I don’t understand Twitter—how it works, how it makes money, or anything. As a computer engineer, I marvel at how impressive it is in terms of scale. For example, they are now crunching 50,000,000 tweets per day. That’s incredible.

Volume doesn’t make it awesome, though. Most of those tweets are about what uninteresting people are eating, watching, etc. Here’s why it’s awesome: I am empowered to connect with people in otherwise unreachable places. This calls for some examples:

Example 1: Microsoft

I recently ranted a bit about Visual Studio 2010 RC crashes:

If you crash on me one more damn time, VS2010, I will drop kick you onto the roof of my building. I'm not even kidding. 9:58 PM Feb 24th

It's official, VS2010 is getting taped to a ball and kicked onto the roof of my office tomorrow. Hope you're happy...(I warned you). 10:59 PM Feb 24th

This brought a very nice reply from someone I’ve never heard of (@Pilchie):

@mharen: Are you using a touch screen? Seen http://bit.ly/dlT7ez ? 11:09 PM Feb 24th

It turns out that @Pilchie is “Dev Lead for C# IntelliSense/Refactoring/etc at Microsoft”. Well how about that? In a mere 10 minutes, I was getting help from not just Microsoft, but the guy who works on the product I was complaining about. And his link worked!

Example 2: Stackoverflow/Codinghorror

I was working on a project which is using a lot of the same libraries that Stackoverflow uses. I ran into trouble with one of the components: I couldn’t figure out which version to use. So I pinged the lead developer/co-creator of SO:

@codinghorror where do i get the best wmd editor for use with markdownsharp? your version on google code? 7:30 PM Feb 8th

And his very prompt response:

r @mharen our version is on Google Code, or you can dig through the fork-splosion on github and try to guess which version is "best" 7:33 PM Feb 8th

In three minutes I had my answer from the top guy of the a product that’s used by bajillions (if not gajillions) of people. Even if he hadn’t answered, I was hoping that someone else might (this wasn’t a private query).

Example 3: Red Gate’s Neil Davidson

Via Twitter, I discovered a neat little book on software pricing. I tweeted about it:

40% in and still interesting... RT @spolsky: A short ebook about software product pricing http://retwt.me/1bmXM (from @neildavidson) 9:10 AM Nov 3rd, 2009

A half-hour later, I see this in my feed:

@mharen Glad you're liking the eBook! If you have time, could you post a review on Amazon once you've finished? ( http://bit.ly/18xFJx) 9:37 AM Nov 3rd, 2009

It’s at this point that I realize who wrote the book: Neil Davidson, co-founder/joint CEO of Red Gate Software, and founder of the Business of Software conferences among other things. A cool guy to get to know, no doubt. I finished the book and left a review as he asked and took the opportunity to ask about one of his products:

@NeilDavidson you bet; we use a lot of your products btw--thanks! What's up with Log Rescue not supporting SQL >2000? Anything planned? 9:40 AM Nov 3rd, 2009

To which I got a very simple and candid reply (the beauty of the 140 character limit!):

@mharen We're not going to do any more work on SQL Log Rescue. Lots of people used it, but nobody bought, and SQL 2000 work would be huge 9:42 AM Nov 3rd, 2009

It’s so cool that this simple medium enables and promotes these types of quick conversations. In 2/3 of these cases, I wasn’t even trying to initiate communication—others were listening for certain things and they found me.

When I first starting toying with Twitter it seemed that its signal-to-noise ratio was cripplingly low. Now I see that by following keywords—not users—the signal is strong.

It also has a unique ability to cut through the BS by forcing you to choose your words carefully. I like that.

Fun with Google’s Public Data

2010-02-27T13:29:00.001-05:00

I was going to do a post about our world’s exploding population growth and stumbled upon Google’s awesome public data service with my first research query:

I haven’t been able to uncover an index for what types of things you can show here but a little searching will get you other things.

Anyway, so this is what I was looking for initially (data source):

And since the last 200 years:

Clearly my source data could be more complete. Even with the gaps, though, the exploding trend is obvious. It comes with this neat, mind-blowing factoid, too:

The total number of humans that have ever lived has been estimated at 110 billion.
Approximately 6% of all those people are alive today.

Wow. With the modern improvements to life expectancy and high rate of population growth (10-15 years per billion), it might be a while before this 6% figure stabilizes (i.e. stops growing).

I’m not suggesting that this is a bad thing—not at all. I just find it interesting.

Word Document Automation with .NET 4: Update All Fields

2010-02-27T12:02:00.001-05:00

I’ve been told that these programming posts are not interesting or funny. For those that have no interest in programming, I offer the following joke:

I hope the next time I move I get a real easy phone number, something that's real easy to remember. Something like two two two two two two two two. I would say "Sweet." And then people would say, "Mitch, how do I get a hold of you?" I'd say, "Just press two for a while. And when I answer, you will know you have pressed two enough." (more classics from the late and invariably hilarious Mitch Hedberg)

Now would be a good time for you to stop reading.

On with the show! This handy method will attempt to update all the fields in the document passed to it:

/// <summary>
/// Update damn near every field in the document
/// </summary>
/// <param name="document">The document in dire need of updating</param>
private static void UpdateAllFields(Document document)
{
    // there must be a better way than searching everything I can thing of
    // please let me know if you find one!

    foreach (Range R in document.StoryRanges)
    {
        R.Fields.Update();
    }

    foreach (TableOfContents T in document.TablesOfContents)
    {
        T.Update();
    }

    foreach (Section S in document.Sections)
    {
        foreach (HeaderFooter F in S.Footers)
        {
            F.Range.Select();
            F.Range.Fields.Update();
        }
        foreach (HeaderFooter H in S.Headers)
        {
            H.Range.Select();
            H.Range.Fields.Update();
        }
    }

    foreach (Shape S in document.Shapes)
    {
        if (S.Type == Microsoft.Office.Core.MsoShapeType.msoTextBox && S.TextFrame.HasText > 0)
        {
            S.TextFrame.TextRange.Fields.Update();
        }
    }

    foreach (Range S in document.Sentences)
    {
        if (S.ShapeRange.Count > 0)
        {
            foreach (Shape Shape in S.ShapeRange)
            {
                if (Shape.Type == Microsoft.Office.Core.MsoShapeType.msoTextBox)
                {
                    Shape.TextFrame.TextRange.Fields.Update();
                }
            }
        }
    }

    document.Application.ActiveWindow.View.Type = WdViewType.wdMasterView;
    document.Application.ActiveWindow.View.Type = WdViewType.wdPrintPreview;
}

To use this, add the following references to your project:

Microsoft.Office.Interop.Word, v12
Office, v12

It makes me cry a little to brute force every container I can think of this way. Surely there’s a better way. Maybe I could just traverse the documents DOM an update anything that looks like a field castable to a Field…I’ll think about that. Until then, this seems to work…

Word Document Automation with .NET 4

2010-02-27T11:31:00.001-05:00

I’ve been toying around with some document generation lately and thought I’d share a bit of what I’ve learned. Here’s a method for extracting a list of custom properties in use in the document:

/// <summary>
/// Retrieves custom properties from a given Word document
/// </summary>
/// <param name="file">Full path to the Word document</param>
/// <returns>A dictionary representation of the document's custom properties</returns>
public static Dictionary<string, string> GetDocProperties(string file)
{
    Application WordApp = null;
    var DocProperties = new Dictionary<string, string>();

    try
    {
        // spin up a new WinWord.exe
        WordApp = new Application();

        // open the specified document
        WordApp.Documents.Open(file);

        // grab the custom properties container
        dynamic CustomProps = WordApp.ActiveDocument.CustomDocumentProperties;

        // extract each property
        foreach (var Prop in CustomProps)
        {
            DocProperties.Add(Prop.Name, Prop.Value);
        }
    }
    finally
    {
        // close doc and shutdown word
        if (WordApp != null)
        {
            if (WordApp.ActiveDocument != null)
            {
                WordApp.ActiveDocument.Close();
            }
            WordApp.Quit();
        }
    }

    // return properties
    return DocProperties;
}

This is so much easier and cleaner with .NET4’s new dynamic capabilities and how nice it plays with COM. To use this, add the following references to your project:

Microsoft.Office.Interop.Word, v12
Office, v12

Bad Haircuts

2009-12-21T22:56:00.001-05:00

A while back I got the worst haircut I’ve ever gotten. I could tell because when men get haircuts, they go unacknowledged (my wife usually doesn’t even notice!). But people noticed me this time.

I could see the flurry of familiar questions each horrified/amused onlooker mentally dismissed when they first met me after the cut…did he cut his own hair? Is that a wig? Did he pay for that? Then I’d invariably see their eyes trace a circle around my head as they imagined the bowl that must have been used as a cutting template. It came out something like this:

Maybe I got what I deserved by going to a place called Fantastic Sams and paying a mere $11.

But wait, since it’s almost Tuesday, let’s make this a twofer. A few months later I went to a Great Clips that had just opened by our house. It turns out that it’s a terrible idea to go to a haircutter’s grand opening. Let me guide you through the cut…

So there I was looking a little scruffy, hoping for a trim, so I hopped into the chair and described what I wanted. The cutter gets started and does the clipper thing and some scissors and we start to talking. I ask my usual question which is something about how busy they are (not).

She said she didn’t know anything about it because she just started and, in fact, is graduating soon…

“From…cosmetology school?”

“No, high school.”

“Oh, so you’re in like a vocational school or something?”

“No, high school.”

“Oh, so you’re planning to go into cosmetology school?”

“No.”

Awesome. “So have you been working in this business long?”

“No…this place just opened and they were hiring so…here we are!”

Hmmm so no training required at all…awesome. So she’s cutting my hair and doing the clippers and scissors and clippers and scissors and back again to clippers…? I’m detecting a problem. It seems she’s going back and forth—temple to temple—with the clippers and moving towards the top of my head as she goes. I suggest that we stop with the clippers

“hmmm that’s probably enough with the clippers”

“I know, I just can’t get it even…” buzzzzzzz

“Ok, it looks good…no—yep it’s great—no…no—ok there, now it’s great.” No more need for those clippers…or scissors. “We’re done here.” (it went something like that).

So I was done and had what I guess was just a hack job that resembled something like this:

(artist rendering)

Then I’m not sure how this happened, but Sarah (who only rarely gets her hair cut), decided to get a trim and got the same person! I swear I didn’t know, babe—honest!

Sarah asked for a trim up to her shoulders—about an inch. The cutter took about 3 inches off. When Sarah’s hair was flying fast and free well above her shoulders, the cutter suggested that her hair bounced up quite a bit with its curl. Her hair is not curly. At all.

After the cut, Sarah thought she got a mediocre cut but didn’t think much of it until we put our stories together. She apparently had some good conversation herself. My favorite response came when Sarah asked the cutter if she grew up cutting her family members’ hair:

“Oh no, I’m not allowed to cut my little sister's hair.”

Wow.

New Website

2009-11-08T00:08:00.008-05:00

My super amazing wife has started her own blog. It is phenomenal. Some of the best stuff I've read in a LONG time. Seriously. You should check it out. Oh, and this is totally not her hijacking my site*

*actually it is

Food Allergies != Fun

2009-09-30T23:35:00.001-04:00

Sarah and I grew up without allergies and in allergy-free homes with allergy-free extended families and mostly allergy-free friends. That’s why it’s so strange to us that Maya has unpleasant sensitivities to so many different foods.

The confirmed list of banned foods includes:

Tomatoes
Pineapple
Blueberries
Dairy

And some recent probable foods:

Soy
Corn

In case you haven’t checked a food label recently, that means she can’t eat anything. No cheese, ice cream, ketchup, fruit salad, anything sweetened with corn syrup (e.g. almost everything), anything with soybeans or soybean oil (everything else), or anything with butter in it.

Maybe I’m being a little dramatic—she’s not going to starve—it’s just very difficult to get used to and impossible to eat meals prepared by others. She gets by on a solid diet of delicious home-cooked meals, supplemented with scrambled eggs and peanut butter.

Fortunately, Sarah’s taken this all in stride. She bakes all of our bread and sandwich buns (you cannot find buns that are safe for her to eat at a regular store—it’s crazy), and somehow prepares three meals a day for her and dinner for us without the above ingredients…and they’re good.

So as you might imagine, we’ve become quite good at reading food labels. We love that labels are often very clear, including nice bold statement like “contains milk, soy”, but sometimes they hide ingredients behind phrases like “natural flavors” and “spices”. As a parent trying to figure out why my almost-two-year-old daughter is sensitive to a dish it’s very helpful to know what’s actually in it. Concealing ingredients behind groupings like those is very frustrating for us.

A recent example of our struggle is Progresso chicken broth. What’s in chicken broth you say? According to the product label, the website, the toll free number on the back of the box, and the letter they sent us, this is what’s in there:

Ingredients: Chicken Broth, Sea Salt, Sugar, Autolyzed Yeast Extract, Carrot Puree, Natural Flavor, Salt, Chicken Powder, Chicken Fat*, Celery Juice Concentrate, Onion Powder, Chicken Meat, Carrot Juice Concentrate, Spices, Onion Juice Concentrate, Garlic Powder. [underlining added]

Oh, so the first ingredient in broth is…broth. That makes sense. So Sarah emailed and called Progresso to find out what exactly are: chicken broth, natural flavor, and spices. I’m wondering what chicken powder is, too, but that’s for another day. Their response: we don’t know (i.e. they don’t tell us so we can’t tell you). I called again and pressed further and was simply told to stop buying Progresso Broth if I was worried about it because they can’t tell me what’s in it.

Well that was frustrating. This as a great example of a company failing to win a customer. There’s probably a dozen reasons not to tell us what’s behind those ingredients but I can’t think of one that really stands up to scrutiny. It’s not like we’re going to start making our own broth. Plus, if I was a real competitor, I would think more scientific approaches to figuring out what is in the box would be more fruitful. Instead of giving us a complete, uncensored list of ingredients like Superior Touch did for their Better Than Bullion product (they were awesome—completely answered our questions in a single phone call), they took our name and promised a call back. Days later, the callback was unhelpful. Weeks later, we received a package from General Mills, Progresso’s parent company. This contained a letter with the same unhelpful answer: we won’t tell you what’s in there, but thanks!

As expected, they included some coupons for more broth (which we can’t use in anything Maya touches because we still don’t know what’s in it). Unexpected, though, was the reason for the package: they included a bunch of General Mills-themed matchbox cars. Seriously—we have four of these things:

(Charlotte pictured, not Maya)

Maya loves them. So, Progresso, thanks for the coupons and the toys—I guess we’re even. I wish I could feed your product to my child, though!

To Fail Or Not To Fail; Plus Bonus Ruminations

2009-09-29T00:03:00.001-04:00

A hilarious meme popular in my social group right now is that of the fail. This is inspired by many popular sites, the most notable being FailBlog. a “fail” is an act of failure concluded with the (typically third-party) exclamation “fail”. Some examples:

While trying to refill a honey bear, I over filled causing quite a mess. Upon seeing my error, a witness is right to proclaim, “Fail!”. This is also increasingly popular in photos. For example, FailBlog is full of sign fails and science fails like these:

But you already know this. Why would I spend so much time defining a fail? Because apparently it’s not so obvious to a certain group of BabyCenter moms. Here are a few Fail fails:

What’s the fail? Are they not girls? Is one of them not yours?

But they do match. You don’t get how this works…

Is it because the kid isn’t smiling at your song? Or is this a song lyric grammar fail? Sigh…

Sometimes, it’s a genuine fail, but needs a much, much shorter title (e.g. “Fail”):

The problem is that a true fail is self evident and most of these are not. Adding extra words to the caption should only carefully be done to add an extra punch.

In the spirit of all things fail, here are a few pics I snapped on the way to work recently:

Commute Fail

Fire Fighting FTW

On my way to work the fire truck pulled out in front of me and while I waited at a traffic light, they extinguished the flames shooting out of that car. Good work guys!

Here’s another encountered while trying to start up a VM on my Windows 7 machine (for those lucky enough to not be familiar with this, it’s the BSOD—what you see when your computer decides to suddenly stop working):

If you want some more funny pics, check out some recent protester signs.

While I’m dumping photos off my phone, here are some non-fail ruminations.

Once a year, Starbucks seduces its coffee loyalists (warning: avoid mental image!):

And on the other side of the same easel, we’ve got a number of problems. We’re missing an apostrophe, it’s already well after 2pm, and what does that mean about the tax? It’s applicable some places but not here, where I am?

Impressive hand-writing, though!

Pictures don’t do this next one justice. It was the saddest water feature I’ve seen in a long time:

Despite its imposing size, it had just one little stream of water which did not do well to cover up the pump or wires powering the thing.

On to more serious matters: getting busy. Here’s family prevention section at Target:

A few observations:

The top two shelves are only necessary if something from a lower self has let you down or wasn’t in use
A purchase from the lower shelves is probably always done with a smile (thus the cool product names)
Purchases from the top shelves, however, are undoubtedly nervous buys (even if you’re trying to become pregnant), and thus the professional product names (peeing on a stick never looked so…idk)
This could be a nice (i.e. hilarious) way to bring up the pregnancy topic with your significant other. Simply peruse the aisle and instead of reaching in for some family prevention, pick up some family detection

Anyone remember Microsoft Bob? Here’s a kid’s version available today:

And finally, I leave you with something that rarely happens as planned: