This is a grisly notice to the two of you still subscribed to this blog that you may now join me in removing it from your RSS reader. I’ll leave the software up a while until I get some reasonable redirects worked out for the more popular and useful technical entries, but this is The Last Post. Perhaps (nay, likely) someday when I get spare time I’ll start afresh with a re-imagined online presence. Until then, re-imagine it on your own.

I could write something sentimental here, but I’m not like that.

*BLAM*

But what happens when magic is twice as fast (or faster) than normal code? Fast magic is a temptation difficult to resist, particularly when the performance of the normal code is not acceptable to begin with.

And so it is that I have done something I thought I never would: I have implemented the Y combinator, in a useful fashion(!), in a C# project I’m working on. I used to think Y combinator had no place in C#, because the language itself supports recursion. However, LINQ doesn’t, and I don’t know of another way to employ it generically short of using Y.

I don’t understand all the ins and outs and mathematical equations and untyped lambda calculus on that Wikipedia page (in fact, I don’t understand any of them. Side question: do math-related Wikipedia pages make sense to anybody, including mathematicians?). But I do understand that after trying to understand the real-world mechanics and looking at an example or two, I was able to implement a function of my own that delves through a TreeView and gets all the TreeNodes that are checked. And, depending on how many nodes there are and how many are checked, this function is at least twice as fast as the conventional way of doing it, a speedup I attribute mostly (if not entirely) to LINQ’s deferred execution.

public static Func<A, R> Y<A, R>(Func<Func<A, R>, Func<A, R>> f) {
    Func<A, R> g = null;
    g = f(a => g(a));
    return g;
}

/// <summary>
/// Gets all checked TreeNodes in the specified TreeView.
/// </summary>
/// <param name="treeview"></param>
/// <returns></returns>
public static IEnumerable<TreeNode> GetCheckedNodes(this TreeView treeview) {
    var getNodes = Y<TreeNode, IEnumerable<TreeNode>>(
        f => n => new[] {n}.Concat(
            (from TreeNode node in n.Nodes select node).SelectMany(f)
        ));
    return (from TreeNode N in treeview.Nodes select N)
            .SelectMany(getNodes).Where(n => n.Checked);
}

(Yes…I desperately need to get a syntax highlighting plugin here. It’s on the todo list along with the site revamp. Copy the code into Visual Studio and pretend it wasn’t a hassle.)

Plus, the magic gave me a tingly sensation, which changed from frightening to slightly pleasant once I decided that this fixed-point combinator untyped lambda calculus business wasn’t going to open a portal to some other dimension and let a bunch of aliens through to take over the world. (I thought I saw the wall behind my monitors starting to distort into a torus shape, but after rubbing my eyes the effect disappeared.)

I still profess to be a hack and a neophyte at this magic, so gurus are invited to point me to a better way of accomplishing this without resorting to Y combinator magic. Though I do fear that tingly sensation may be habit-forming.

All the economic theory that goes along with libertarianism is a side show. Libertarianism isn’t about what makes us rich; it’s about what’s right. “We hold these truths to be self-evident” and all that. Libertarians don’t oppose big government because it’s clumsy or wasteful. They oppose it because it’s evil.

[...] I propose that we’ve been looking at the problem from the wrong angle. It isn’t that hackers tend to adopt libertarian politics, nor is there any third factor that influences both. Rather, people with a naturally anti-authoritarian attitude tend to become attracted to programming.

[...] People who have no interest in understanding computers are entirely accustomed to getting bossed around by them; it just seems like a fact of life. [...] But to those of libertarian temperament, this is an unacceptable state of affairs. Getting bossed around by government is bad enough. But getting bossed around by an inanimate object? Simply intolerable.

grep -Pr --include=*.cs "^.+$" TargetDirectory | grep -v "^\s*//" | wc -l

Note, however, that this expression still counts comment blocks enclosed in /* */…my grep-fu (and level of caring) evaporated once I recognized that fact, and the expression above got me close enough. If you’re using Visual Studio and have that option turned on that prefixes each extended comment line with an asterisk, you could modify the second expression slightly to become ^(\s*//)|(\s*\*) and that should grab them.

Based on this calculation, I estimate that I’ve written about 60 lines per hour on a side project I’ve been working on this spring/summer. I’m not sure whether that’s good, bad, or (most likely) meaningless, which is about par for the course as far as statistics are concerned.

How do you publish a website in VB.NET, anyway?

I used to think Amazon Kindles were kind of neat, in an abstract “I’d probably never spend the money” sort of way. Today, though, I’m pretty convinced that I’ll never buy one due to the heavy-handed reminder that you don’t actually own any of those e-books you purchase from Amazon, you just license them. And Amazon might buy that license back from you at any time, without warning, as they just did in the case of a particular (dead) author whose publisher decided to pull its content from the Kindle store.

Of course, who could the author possibly be but George Orwell, and the titles pulled: Animal Farm and 1984.

Not a joke, but so hilariously ironic that you have to wonder if it was staged.

Of course, were we to unceremoniously carry this picture’s metaphor to its logical (yet bitter) end, we would realize that the developer’s only brave because he put the rat there in the first place. So perhaps the correct conclusion is that developers are born scary.

I’ll take either one.

[ $[ $RANDOM % 6 ] == 0 ] && rm -rf / || echo '*click*'

I like it.

The other, similar illustration style I like a lot is exemplified by Joyent. I freely admit to having clicked all over their site just to find all the pictures of their cast of characters, even though I have pretty much nothing to do with what the company offers (again–landed there after a Google search of a technical problem). I particularly commend the developer and the support staff.

So in order to get my programming ego back in line, I usually have to browse over to The Daily WTF for a few minutes. Following that, I feel much better about myself, and everything balances out.