Friday Night Magic, a Pre-pre-release thoughts.

Aha! It’s been days since my last post, so I should do it now.

Tonight was a fine day. I played in the Friday Night Magic at my local game story (Limited Edition). We drafted M11, and I got some nice cards in red, white, and blue, and though it pained me to play three colors, I decided to go for it anyway. Let me list out some of the good cards in each color.

• Red: Fireball, Chandra’s Outrage, Ember Hauler, Fling
• White: Pacifism, Day of Judgment, 2x Cloud Crusader, 2x Stormfront Pegasus
• Blue: 2x Scroll Thief, Foresee, Mana Leak, Ice Cage
• Colorless: Crystal Ball

Signals were all messed up during the draft, which is why I ended up with so many playables in three colors. Pack 1 Pick 1 was an interesting dilemma: Stormfront Pegasus vs Sign in Blood? I picked the Pegasus because of its power and flexibility, but if I were to do it all over again, I’d pick the Sign in Blood and try to force black. I probably wouldn’t be very successful, but I love mono-black in this format. *blush*

My matches went as follows:

• Match 1 vs GU: First game, I dealt 15 damage in one turn (Fireball + Ember Hauler + swing with Chandra’s Spitfire), putting my opponent at 0. The second game ended quickly when I had 3 creatures out and my opponent had none (yet). 2-0
• Match 2 vs RW aggro: The first game I won somehow (I don’t remember). Second game, my opponent had me down to 8 before I could stabilize. To stabilize, I Fireballed 3 of his creatures, and Ice Caged the other. Vulshok Berserker went in for damage, and the Spitfire helped to deliver the win quickly. After the match, my opponent revealed the Lava Axe in his hand — that was the reason I had earlier chump blocked a vanilla 3/3 with my scroll thief.
• Match 3 vs UB control: Both games, my opponent led with a Leyline of Anticipation (in his hand). Both games, my opponent handily won. So unfair, augh. My own damn fault for not drafting any enchantment removal.

—

Tomorow it’s the Scars of Mirroding prerelease! I’m excited!

There are a few cards that I would die to crack: Mimic Vat, Skithyrix, the Blight Dragon, Oxidda Scrapmelter, Nim Deathmantle, Infiltration Lens, Skinrender, Sky-eel school… so many nice cards. I’m sure I’ll open one or two of these.

Red has a lot of removal in Mirrodin (due to it being just about the best artifact remover out there, and also having the direct damage that can be used to kill creatures).

Here’s some math on Grindclock (in a limited context):

• charge 1, mill 16 times (17 + 8 + 16 == 41)
• charge 2, mill 10 times (12 + 8 + 20 == 40)
• charge 3, mill 8 times (11 + 8 + 24 == 43) — acceptable
• charge 4, mill 6 times (10 + 8 + 24 == 42) — seems optimal, even if played on turn 4, instead of turn 2
• charge 5, mill 5 times (10 + 8 + 25 == 43) — acceptable
• charge 6, mill 4 times (10 + 8 + 24 == 42)… yeah, this stops now

I’ll probably play Grindclock if I open it, even without Screeching Silcaw to help out. Grindclock is scary. If the opponent Shatters it, no biggie. It means that they didn’t shatter some other scary artifact.

Anyway… I should go to sleep so I’m ready to go tomorrow. Ta ta, folks!

Back to Qwerty

So, clearly, the Dvorak thing didn’t last very long. If I didn’t want to be so productive, I would have time to get used to the Dvorak keyboard. A week or so ago, I tried to move to the Dvorak keyboard because it should reduce RSI, and because it should, over time, make me a more efficient typist. As it is, I can type pretty damn fast, but I occasionally have to look down at the keyboard, and my posture is seriously different from the “recommended” posture. I tend to type most letters with my left hand, using my right hand for most of the punctuation and special keys (and, of course, any letters that are hard to reach with the left hand). Ultimately, I don’t think my way of typing is terrible. If I start to develop pains, I will make amends.

Another thing that didn’t last long was the idea that I would post every day. Why is it so difficult to post every day? Here’s why:

• Coming up with things to say every day is complicated.
• Dedicating time to put these things in a coherent order is also complicated.
• Improving the quality of your writing (i.e. editing) also takes time.

In order to do achieve the goal of posting every day, I need to:

• Learn something new every day, so that I have something to say.
• Make writing a dedicated part of my daily schedule.
• Also make editing a dedicated part of my daily schedule (separate from writing).

I don’t know if I can commit to all of this. Maybe I’ll tell you tomorrow. :p

Dvorak — Braindead.

I’ve switched to the Dvorak keyboard layout today, and I’m learning to touch-type at the same time. I must hate / love myself, if I’m willing to go through so much pain for my own sake… (Apropos, Last.fm was playing Jill Tracy’s “Just the other side of pain” during that last sentence).

What are the advantages of putting myself through this pain? Let’s list them.

• Dvorak keyboards can help prevent or reduce RSI (Repetitive Strain Injury), by cutting down on awkward finger/hand movement.
• A trained Dvorak-ist can type (English) faster than a trained QWERTY-ist.
• Touch typing is the fastest known method of typing.

The first reason is the real reason why I’m going through this. I don’t truly care that much for speed. I doubt I’ll get to my previous speed in a long time, let alone exceed it. That’s partly why I’m restarting this blog (“Yay!” shouts the audience). The other reason is to get better at writing, so that I can become a successful academic.

I’ve been at this for almost an hour, and I have roughly 170 words. Time to stop. My goal for tomorrow is 250 words. Wish me luck!

Small Shots of Lambda Calculus, Part III

Last time, we talked about pairs and more complex arithmetic, and we previously discussed the basics of lambda calculus and simple arithmetic.

This time we’re going to talk about lists.

There are several different ways to define lists in lambda calculus. One way is as a more complicated pair. We use cons and nil to construct lists:

> cons h t f x = f h t
> nil      f x = x

And we use head and tail to get the first item and all but the first items, respectively:

> head_ x l = l (\h t -> h)
> head = head_ 0
> tail_ x l = l (\h t -> t)
> tail = tail_ nil

Here’s some example of using these in our imaginary lambda calculus interpreter:

>>> cons 1 nil
cons 1 nil

>>> head (cons 1 nil)
1

>>> tail (cons 1 nil)
nil

>>> head nil
0

>>> tail nil
nil

This is all well and good, but it’s kind of boring. These lists are basically no different from pairs and, in order to do anything useful such as mappings and folds, we have to go jump through hoops of complexity.

Perhaps this is best, for otherwise we might’ve been content with this representation for lists and not have found the other viable representation, which I consider to be the most elegant.

An empty list is nil:

> nil f x = x

Note that nil is unchanged, and that nil has the same definition as 0.

To construct the list we use cons:

> cons h t f x = f h (t f x)

This is very similar to the succ function we defined in Part 1. To understand how it works, we should look at some sample lists. (Note our list shorthand: comma separated list of values encased in square brackets.)

>>> [] f x
x

>>> [1] f x
f 1 x

>>> [1,2] f x
f 1 (f 2 x)

>>> [1,2,3] f x
f 1 (f 2 (f 3 x))

Compare this to the way numbers are defined:

>>> 0 f x
x

>>> 1 f x
f x

>>> 2 f x
f (f x)

>>> 3 f x
f (f (f x))

It’s hard to argue that there’s a more natural way of expressing lists in lambda calculus.*

It’s easy to get the head value:

> head_ x l = l (\h v -> h) x
> head = head_ 0

>>> head []
0

>>> head [1]
1

>>> head [1,2]
1

But getting the tail is hard, like getting the predecessor of a number:

> tail_ x l = 1st (l (\h p -> pair (2nd p) (cons h (2nd p)))
                     (pair x nil))
> tail = tail_ nil

>>> tail []
[]

>>> tail [1]
[]

>>> tail [1,2]
[2]

>>> tail [1,2,3]
[2,3]

Actually tail works just like pred, but instead of doing succ each iteration, it does cons h.

Some properties and predicates:

> length l = l (\h n -> succ n) 0
> nil?   l = l (\h b -> false) true
> sum    l = l add 0

>>> length []
0

>>> length [1,2,3,4]
4

>>> nil? []
true

>>> nil? [1,2,3,4]
false

>>> sum []
0

>>> sum [1,2,3,4]
10

We should also define map (which passes a function through all items of a list):

> map f l = l (\h v -> cons (f h) v) nil

>>> map (add 5) []
[]

>>> map (add 5) [3]
[8]

>>> map (\x -> mul x x) [1,2,3,4,5]
[1,4,9,16,25]

That’s it for today. Tell me what else you’d like to know about Lambda Calculus (in the comments on reddit preferably, but I’ll answer to the ones below too).

Footnotes

* – By the way, this list representation corresponds to Haskell’s foldr.

Blog Moved

My less-than-amazing “A different kind of uselessness.” blog over at blogpost has been moved to WordPress.

Bask in the glory of the title change.

I shall post something of substance tomorrow, don’t worry.