Click it it is a link.

Because of his pedigree his name had to start with an L, so we called him Linus.

I recorded that video using my new ThinkPad® Tablet, which leads me to a question which I will phrase as a demand: recommend some Android “apps” I can download to make that thing suck less. They should at least be free as in beer because I don’t have a credit card, and ideally free as in Stallman too.
I’m specifically looking for a good terminal emulator (currently using Terminal Emulator, which is balls), an SSH client, something to read PDFs and ideally PostScript files with, and maybe an emulator for one or more of the better gaman consoles, but feel free to recommend whatever you find noteworthy.

(I already know about Angry Birds and the Minecraft demo and don’t care for either.)

Hint: the correct answer is “not a damn one”.

Yes, I’ve been playing a lot of Pokémon in the past year or so, so yes, it was inevitable I’d eventually attempt to acquire some of the GBA games. Belgian toy stores don’t tend to do trade-ins or sell old second-hand games, and I hate interacting directly with people (so eBay or the local equivalent, 2dehands.be, are out), and Amazon doesn’t deliver here, so it took me a bit to find an actual place to get them, but eventually I did find this Amazon clone, which has the added bonus of free shipping to most of Europe.
I’d like to make it clear my misadventures involving Pokémon Emerald are no reflection on the website itself or most sellers using it; several sellers refunded my money when I pointed out the games were bootlegs, and I’ve had few to no issues with the other things I’ve ordered there (including three DS games and a GameCube game, controller, and memory card).

For Pokémon Emerald, though, holy fuck. I’ve made seven attempts to buy this game; the four bootlegs pictured, two orders that were refused because the seller was out of stock but forgot to take down his listing, and my personal favourite, this fucking thing:

Apart from the fact that it’s not the right game, look at the effort that went into it. They wrote a (six-page, admittedly) manual. They printed a box with fancy metallic sparkles. They actually folded a cardboard thing to keep the cartridge in place as if it were the real deal. At no point did it occur to them to look at the actual box art to ensure their efforts weren’t ludicrously misdirected.
The real Pokémon LeafGreen comes with a GBA wireless adaptor, by the way (because link cables are passé). This one obviously didn’t, but the manual, which they wrote themselves, from scratch, still promises it.

I do actually own a legitimate copy of LeafGreen (also without wireless adaptor, but that’s to be expected). Here it is with my legitimate copy of FireRed,⁰ and the bootleg copy of FireRed I got on my first attempt (fucker didn’t even send me a box for that one):

Obvious things to notice: the bootleg has a battery (that round thing partially visible through the plastic), the real ones don’t; the Nintendo seal is oval on the bootleg; the label has a metallic effect on the genuine cartridges.
One thing all of my bootlegs have in common is that when they’re started, they give a pointless message. All of the Emeralds give the following:

The save file will be loaded.
The game can be played.

Except for the one that used to give that but now gives this one:

The save file has been erased due to corruption or damage.
The game can be played.

(In case you were wondering why it matters to me that I have a genuine cartridge. And oh: none of the bootlegs I’ve bothered to test allow migration of Pokémon to the fourth-gen games.)

The bootleg FireRed and LeafGreen are terser:

The save file is ok.

Real games don’t give any message when there’s no problem. I suspect the reason bootlegs do is because the save mechanism is so closely tied to the hardware of the cartridge itself that it has to be reimplemented by the bootleggers (unlike the rest of the game, which is just a ROM ripped from a legitimate cartridge, obviously), and bootleggers don’t give a shit. Further evidence for this hypothesis is the fact that my bootleg FireRed and LeafGreen have batteries, which they presumably use to save to volatile memory, in the same way old Game Boy and Game Boy Color games did, but the GBA games no longer do (they use flash memory).

Incidentally, the presence of a battery on an Emerald cartridge is not automatic evidence of bootleggery: legitimate Ruby, Sapphire, and Emerald cartridges all have batteries, which they use to keep time, because the GBA doesn’t. When those batteries run out, you don’t lose your save (unlike you would for GB and GBC games), but you’ll lose events that rely on the clock, like berry growing and tides in the Shoal Cave. It can be replaced with relatively little risk to your game.

For science, here’s the backs of those Emerald cartridges, in the same order as above:

Note that despite differing labels and cartridge plastic, three of those are actually the same circuit boards. And to give the bootleggers credit, they actually did bother to print “Nintendo” on the board just above the connectors, which is a thing that’s often mentioned in guides about spotting bootlegs; it’s in the wrong font (which annoys me in its gratuitous indifference), but a pretty casual consumer might not notice.

My point, I suppose, is caveat emptor. And if you’re going to buy Pokémon GBA games second-hand, ignore the guides and just check if it gives you a startup message; that seems to be the easiest and only sure-fire way to know.
But my secondary point is that you should mail me your copy of Emerald if you aren’t playing it anymore. After the first two bootlegs I told myself I’d keep buying them until I either got a genuine one or spent €50, and unless one of the three most recent scammers refunds my money, I’ve hit that limit.

Maybe I’ll try for Ruby and Sapphire instead.

Edit (June 11): So I never did get those refunds, but I noticed the same person who sold me my genuine copies of FireRed and LeafGreen had a copy of Emerald. It was €34, but I decided to chance it.

Finally.
Note how the connectors are visible from the back of the cartridge. The label is a bit worn, but there’s a holo type effect that isn’t very visible in pictures. And, importantly, there’s no message when you start the game.

It took €84 and six months, but I finally own a genuine copy of Pokémon Emerald.

⁰ Both of those genuine cartridges came from the same seller. Unfortunately, she doesn’t have Emerald. See edit!

The Selected Works of T.S. Spivet Reif Larsen
The Stuff of Thought Steven Pinker
Hard-boiled Wonderland and the End of the World Haruki Murakami
The Humans Who Went Extinct Clive Finlayson
Chronic City Jonathan Lethem
Why Beauty Is Truth Ian Stewart
The Remains of the Day Kazuo Ishiguro
Norwegian Wood Haruki Murakami
Letters to a Young Mathematician Ian Stewart
The Jungle Books Rudyard Kipling
Die Verwandlung Franz Kafka
South of the Border, West of the Sun Haruki Murakami
The Brain that Changes Itself Norman Doidge
Special Topics in Calamity Physics Marisha Pessl
A Wild Sheep Chase Haruki Murakami
Kafka on the Shore Haruki Murakami
Oblivion: Stories David Foster Wallace
Sputnik Sweetheart Haruki Murakami
The Adventures of Huckleberry Finn Mark Twain
1089 and All That: a Journey Into Mathematics David Acheson
Bad Science Ben Goldacre
The Lightness of Being Frank Wilczek
Dance Dance Dance Haruki Murakami
Birthday Stories Haruki Murakami (ed.)
Lights Out in Wonderland Peter “DBC Pierre” Finlay
The Great Gatsby F. Scott Fitzgerald
Underground Haruki Murakami
Artificial Intelligence: A Modern Approach Stuart Russell, Peter Norvig
McSweeney’s Thirty-Two Dave Eggers (ed.)
The Corrections Jonathan Franzen
Content and Consciousness Daniel Dennett
De Eeuwige Terugkeer van het Fascisme Rob Riemen
The Ascent of Man Jacob Bronowski
after the quake Haruki Murakami
The Bottom Billion Paul Collier
Haroun and the Sea of Stories Salman Rushdie
The Crucible Arthur Miller
Remarkable Creatures Sean B. Carroll
Flaubert’s Parrot Julian Barnes
What I Talk About When I Talk About Running Haruki Murakami
Foundation Isaac Asimov
Blind Willow, Sleeping Woman Haruki Murakami
After Dark Haruki Murakami
Taming the Infinite Ian Stewart
The Grand Design Stephen Hawking, Leonard Mlodinow
Schaum’s Outlines: Logic John Nolt, Dennis Rohatyn, Achille Varzi
Hitch-22 Christopher Hitchens
I Shall Wear Midnight Terry Pratchett
The Discomfort Zone Jonathan Franzen
Alex’s Adventures in Numberland Alex Bellos
The Magic of Reality Richard Dawkins
1000 Years of Annoying the French Stephen Clarke
Mathematics Without Fear Lawrence Potter
Mathematics of Life Ian Stewart
Ubik Philip K. Dick
Naked Lunch William S. Burroughs
Go the Fuck to Sleep Adam Mansbach
Chaos James Gleick
Fury Salman Rushdie
I Am Number Four James Frey, Jobie Hughes
Warped Passages Lisa Randall
The Emperor of All Maladies Siddhartha Mukherjee
The Beetle Richard Marsh
The Rational Optimist Matt Ridley

Would’ve been more, except I bought a DS in July and Pokémon has interfered with my reading. My goal for the year was 50, as it always is, so I did at least make that.

I also said 2011 was going to be the year in which I read everything Haruki Murakami has ever written (that I hadn’t read the year before), and while I didn’t do that, I got a lot closer than I did for Margaret Atwood in 2010; I read everything he’s ever written that’s been translated to English and released outside of Japan (Hear the Wind Sing and Pinball, 1973 have been translated into English, but those translations were never released outside of Japan), except for 1Q84, which I did buy and start in, but didn’t manage to finish.
I can’t recommend you try to do this. Any individual book of Murakami’s is pretty good to great, but reading all of them that quickly will make you dislike either the books or Murakami himself. His non-fiction is merely boring for the most part, but the shared aspects of his fiction show him to be an unpleasant, frustrated little man.

I’ve written reviews of nearly everything I’ve read, so if you’re looking for those I suggest you go to GoodReads.
Since I did this last year, I might as well do it now:

Better than expected

The Emperor of All Maladies, by Siddhartha Mukherjee, was surprisingly good. It’s about cancer and the history of cancer research, and it’s pretty US-centric but otherwise very interesting. Since everyone will either get cancer themselves or be close to someone who will, there’s really nobody who can afford not to read it.

Warped Passages by Lisa Randall is possibly the best pop-sci treatment of modern physics I’ve seen, despite Lisa Randall being a pretty unpleasant person. As I said in my review, it’s possibly the first book in its genre that I’ve read that didn’t leave me feeling like modern physics is just too complicated and esoteric now to be viable subject matter for pop sci.

The Beetle by Richard Marsh is the only fiction entry here; a decade or so ago my expectations of it would have been spot on, but years of Lovecraft and Stoker and (even worse) their imitators have destroyed my expectations of classic horror and left me cynical.

Worse than expected

Matt Ridley’s The Rational Optimist. This is the same Ridley who wrote The Red Queen, which I gave five stars in 2008. Apparently he’s like Penn & Teller in that he’s only capable of intelligent discourse on subjects on which his political masters have no opinion; for P&T this is the Cato Institute, for Ridley it’s the British Tory party.

Oh, and Hitch-22, by Christopher Hitchens, I guess. I never really cared for him and my expectations weren’t too high, but he still managed to be worse than I imagined. I’m not even talking about the casual misogyny everyone has come to expect of him by now; I’m talking about how every position Hitchens has ever held he has only held because his father or his brother have held the opposite. He sure wasted shit-tons of paper on rationalisations trying to convince himself otherwise, though.

Like last year, there are also a lot of books that were shit that I expected to be, and books that were good that I expected to be. GoodReads lets you sort by rating, if you’re interested.
Either way, discuss.

tl;dr: GoodReads.

Building a LackRack is some sort of rite of passage for sysadmins, I think, and I am, after all a sys- and network admin first and a programmer second. Initially the idea was just to have the switch, and the second table was just to make it look like a respectable piece of furniture instead of a €5 Ikea table (as per this picture I posted a month ago), but then I figured a power strip would be useful, and in the process of locating a Belgian supplier I found more things I wanted.
I did add the power strip; I added two, in fact. Here’s the front one:

It’s sunken not to protect plugs or even to help support the 4U drawer above it (which needs the support; it’s solid steel and weighs 17 kg), but because the power cable is to the side and there was no other way to mount it. Still, it was the only power strip available, and we make do.
(Notice that it also has Schuko sockets rather than the more sensible CEE 7/5. Fortunately everything I wanted to use it for has either CEE 7/7 plugs or Europlugs.)

Here’s the view from the back, showing the second power strip:

Note the connector plates with which I expertly affixed the top table to the bottom. There’s four such plates because that’s all I could find in our basement. On the front legs they’re on the side, for looks.
The dorsal power strip faces inward, because there’s no reason for it not to. It holds everything that needs to have power 24/7, including the front power strip, the switch, my electric toothbrush, and the laptop on the shelf under the switch.
The frontal power strip is meant to be switched off at night, because I have a lot of things that have too many bright lights to keep them on in my bedroom, including my Wii, the inductive charger for the Wii remote, and the Roomba, for which there’s just enough space underneath.

That’s the switch’s power cable, plugged into the dorsal strip. The duct tape shows it’s professional.
Here’s the whole thing from the side:

Ignore the dust and the fingerprints.
The shelf doesn’t look too stable, which may be a problem. The table legs are hollow at the point where it’s attached, and it’s not particularly light-weight, being entirely steelen as well. Still, it seems to be holding. I’ll add some sort of reinforcing bracket if I find one.
It slides out, too!

And here’s what the whole thing looks like when it’s running:

Again, ignore the dust and general grime. My room needs cleaning and will get it tomorrow. Also ignore the quality of the connector attachment on the leftmost cable. I didn’t do it, though I will redo it, also tomorrow.
The point of the laptop is to have a shell server (as I’m apparently graduating this year, which means I won’t have access to the one I’ve been using for the past half-decade anymore) and, as soon as the new hard drive arrives, a backup server. I was initially going to get a proper rack-mounted server instead, but my old laptop still works, so why not use it?

The total cost of this is €568.81 (€289.90 for the switch, €45.98 for the cable and connectors (admittedly I have 98 meters and 44 connectors left, which is what the drawer is for), €222.95 for the shelf, drawer, and power strips (including automatic discount and shipping; LackRack or not, 19-inch equipment isn’t cheap), and €9.98 for the tables), plus whatever the old laptop and the handful of screws I found in the basement cost. I’d say it’s worth it.

Haskell is less impressed.

(If you’re in Belgium and want to do something like this, I recommend both Tones, where I got the switch, the cable, and the connectors (not to mention my Thinkpad and my mom’s inexplicable iPad), and Flightcase-brico.be, where I got the other things. The former has free shipping for orders over €200 and the latter is much faster than you’d expect. Be aware that the latter lists prices without BTW, and BTW is 21% on everything. You don’t need a credit card for either one.)

Officially the point of this project was for the school to have something with which to replace ClusterKnoppix for their Besturingssystemen II class, but really I just wanted to have something nicer to make use of my ever-growing pile of old computers, which is why I finished it. The README explains. (HPC there stands for “high-performance computing” rather than “Hasty Pudding cipher”.)
What I need now is people to test it, ideally by building images and then trying them.

If you’d rather not put that kind of effort in, I’ve also pre-built an image (291 MB). It doesn’t come with X to save space, but it does come with (what else?) this Open MPI tripcode finder I wrote a while ago. It’s not particularly fast, but it reports its progress if you poke it with SIGUSR1 (as in pkill -USR1 tripfind).
The unprivileged user is called gjs, and the password for both him and root is t. I’ve also included the MPI-patched JtR tarball in the home directory for you to build, if that’s less pointless.

Feedback appreciated, even if you don’t find any problems. If you find this project useful at all, or if you have any suggestions, I’d like to hear about it.

$ wget -qO - http://www.gutenberg.org/ebooks/31469.txt.utf8 | ./classific.py
Most likely English.
$ wget -qO - http://www.gutenberg.org/ebooks/22367.txt.utf8 | ./classific.py
Most likely German.
$ wget -qO - http://www.gutenberg.org/ebooks/4968.txt.utf8 | ./classific.py
Most likely French.

On the Road Jack Kerouac
The Robber Bride Margaret Atwood
Does God Play Dice? Ian Stewart
The Pickwick Papers Charles Dickens
Prolog Programming for Articial Intelligence Ivan Bratko
Eating Animals Jonathan Safran Foer
Alias Grace Margaret Atwood
A Strange Manuscript Found in a Copper Cylinder James De Mille
The People’s Train Thomas Keneally
Le tour du monde en 80 jours Jules Verne
Wuthering Heights Emily Brontë
You Are a Mathematician David Wells
Why Evolution is True Jerry Coyne
The Adventures of Sherlock Holmes Arthur Conan Doyle
Cinq semaines en ballon Jules Verne
The Good Man Jesus and the Scoundrel Christ Philip Pullman
The Blind Assassin Margaret Atwood
Northanger Abbey Jane Austen
A Clockwork Orange Anthony Burgess
And Another Thing… Eoin Colfer
The Graveyard Book Neil Gaiman
Cloud Atlas David Mitchell
River Out of Eden Richard Dawkins
The City Curious Jean de Bosschère
Discrete Mathematics Seymour Lipschutz, Marc Lipson
Byzantium Judith Herrin
Oryx and Crake Margaret Atwood
Hard Times Charles Dickens
Cradle to Cradle Michael Braungart, William McDonough
The Penguin Dictionary of Curious and Interesting Numbers David Wells
Surfacing Margaret Atwood
Blood Meridian Cormac McCarthy
The Book Thief Markus Zusak
Little Women Louisa M. Alcott
Year of the Flood Margaret Atwood
Unseen Academicals Terry Pratchett
The Adventures of Tom Sawyer Mark Twain
Moral Disorder Margaret Atwood
Bodily Harm Margaret Atwood
Cows in the Maze Ian Stewart
The Lottery and Other Stories Shirley Jackson
Brave New World Revisited Aldous Huxley
Who Moved My Cheese? Spencer Johnson
Reading Lolita in Tehran Azar Nafisi
Writing Scientific Software Suely Oliveira, David Stewart
Science: a Four Thousand Year History Patricia Fara
Professor Stewart’s Hoard of Mathematical Treasures Ian Stewart
My Man Jeeves P.G. Wodehouse
Linear Algebra Seymour Lipschutz, Marc Lipson
The Bro Code Matt Kuhn
Cat’s Eye Margaret Atwood
The Black Cloud Fred Hoyle
The Fry Chronicles Stephen Fry
The Wind-Up Bird Chronicle Haruki Murakami
Fight Club Charles Palahniuk
The Language Instinct Steven Pinker
The Elephant Vanishes Haruki Murakami
Two Treatises of Government and a Letter Concerning Toleration John Locke

I said that 2010 was going to be the year in which I read everything Margaret Atwood has ever written, but I didn’t manage that. I read everything she wrote that was available in Leuven’s bookstores, but she’s just written too damn much. Maybe I’ll round off the remainder next year, but I think I’m going to focus on Haruki Murakami instead; while his books haven’t changed my mind about reading in translation, the two I’ve read have been good enough to justify it.
As before, I’ve written individual reviews of nearly everything I read this year, but here’s a round-up anyway:

Better than expected

As said, Murakami. Despite its fanbase, The Wind-Up Bird Chronicle is legitimately good, and the short stories in The Elephant Varnishes were excellent as well.
Why Evolution is True by Jerry Coyne was also surprisingly good. I didn’t expect it to be bad, but I also didn’t expect it to be better than, say, Dawkins’ own The Greatest Show on Earth, which set out to do much the same thing as WEIT; but it is.
Judith Herrin’s Byzantium was nice as well, and a good introduction to what is often a blind spot in world history. I picked it up on impulse, because it was there rather than because I’d heard of it, and that usually doesn’t turn out well. It did this time.
Also better than expected was Fred Hoyle’s The Black Cloud, but my expectations of that were very low because I know what kind of a person Fred Hoyle was, and my opinion of science fiction is justifiably low to begin with.
And finally, Jane Austen’s Northanger Abbey. I wouldn’t necessarily call it excellent in its own right, but it’s a lot better than Austen usually is.

Worse than expected

Probably just Patricia Fara’s Science: a Four Thousand Year History. I only expected it to be good because of the pleasing heaviness of the paper and the quality of the print and the illustrations, but it turned out to be Mary Midgley’s strain of science- and scientist-bashing.
It’s by no means the only terrible book I read this year, but my expectations are very low in general. Maybe there should be another category.

Offensively but expectedly terrible

On the Road, Jack Kerouac; And Another Thing…, Eoin Colfer; Cloud Atlas, David Mitchell; Blood Meridian, Cormac McCarthy; Who Moved My Cheese?, Spencer Johnson; Fight Club, Charles Palahniuk; The Language Instinct, Steven Pinker.

Everything else was either “merely” and expectedly bad (Dickens, Burgess, &c.), expectedly alright (Atwood, Dawkins, &c.), or just pretty unremarkable (Keneally, Verne, &c.). More reviews at GoodReads.

In case you aren’t familiar with the problem, the idea is to place all the pieces on the board in such a way that none of them threatens any other.
Clearly we have nine variables (two queens and seven knights), and the domain for each of them is any of the thirty-six positions on the board, represented as a tuple of numbers to indicate the row and column. In Python, we could represent this like this:

> domains = {'Q1': set([(a, b) for a in range(6) for b in range(6)]),
>            'Q2': set([(a, b) for a in range(6) for b in range(6)]),
>            'K1': set([(a, b) for a in range(6) for b in range(6)]),
>            'K2': set([(a, b) for a in range(6) for b in range(6)]),
>            'K3': set([(a, b) for a in range(6) for b in range(6)]),
>            'K4': set([(a, b) for a in range(6) for b in range(6)]),
>            'K5': set([(a, b) for a in range(6) for b in range(6)]),
>            'K6': set([(a, b) for a in range(6) for b in range(6)]),
>            'K7': set([(a, b) for a in range(6) for b in range(6)])}
> 
> pieces = set(domains.keys())
> queens = set(['Q1', 'Q2'])
> knights = pieces - queens

(Using sets not (primarily) because I’m worried there would be duplicate entries there, but because Python’s sets have some useful operations defined on them that lists don’t, as will become clear.)

Representing the constraints may be a bit trickier. We’ll only be working with arc constraints (that is, constraints that apply to exactly two variables), because that makes sense, and it turns out that higher-order constraints aren’t much more useful.⁰ Should you have any single-variable constraints, those can be applied directly to reduce the domains in advance, obviously.
There are a lot of ways to represent this, but I’m going to go with a class that stores the two variables the constraint applies to, plus a constraint function, which operates on two values from the domains of the variables and tells you whether the constraint is satisfied or not. The class also has a valid method, which just applies the constraint function.

> class Constraint():
>     def __init__(self, p1, p2, constr_fun):
>         self.p1, self.p2, self.constr_fun = p1, p2, constr_fun
> 
>     def valid(self, a, b):
>         return self.constr_fun(a, b)

Now for the constraint functions themselves. Remember, these functions take two values from two domains, and return False if the first piece threatens the second (because we’re looking for situations where that doesn’t happen), and True otherwise.
A queen threatens everything on her row, column and diagonals, so her function looks like this:

> def queen_cf(queen, other):
>     return abs(queen[0] - other[0]) != abs(queen[1] - other[1]) \
>        and queen[0] != other[0] \
>        and queen[1] != other[1]

The knight threatens everything two moves in the horizontal or vertical direction plus one in the orthogonal, so its function looks like this:

> def knight_cf(knight, other):
>     if other[0] in (knight[0] - 2, knight[0] + 2):
>         return other[1] not in (knight[1] - 1, knight[1] + 1)
> 
>     if other[1] in (knight[1] - 2, knight[1] + 2):
>         return other[0] not in (knight[0] - 1, knight[0] + 1)
> 
>     return True

(Does it matter that it ignores the limits of the board? Not really: there will never be a piece outside of the board, but it does no harm to look. Explicitly checking board limits isn’t going to save any time.)

Finally, an optional constraint. Consider the following two solutions to our problem:

These are equivalent in every way that matters, of course, but will be returned as different solutions by our algorithm as written. You might think this isn’t a big deal, but there are 2! × 7! identical variants of every possible solution, and there are (it turns out) twenty-two legitimate solutions; paring down 221,760 solutions to find the twenty-two unique ones would be a challenge in its own right.
So let’s enforce the constraint that the position of Q1 must be strictly less than that of Q2, for some unambiguous ordering of the board’s squares, and the same for any knights compared to knights with a higher index. This will ensure that each solution found is genuinely unique. Fortunately, Python makes this easy.

> def index_cf(low, high):
>     return low < high

(Notice that this also implies that no two pieces can ever occupy the same square; otherwise we’d have to introduce another constraint for that, or modify our knight function (the queen function already implies it).)

Building our list of constraints is then relatively straightforward.

> constraints = [Constraint(q, p, queen_cf) for q in queens \
>                                           for p in pieces - set([q])] \
>             + [Constraint(k, p, knight_cf) for k in knights \
>                                            for p in pieces - set([k])] \
>             + [Constraint("Q1", "Q2", index_cf)] \
>             + [Constraint(a, b, index_cf) for a in knights \
>                                           for b in filter(lambda n: n > a,
>                                                           knights)]

And hey, that last constraint function means we can pare down our domains already: Q1 will never be in the highest square, because if there’s a queen there, it will be Q2. Similarly, Q2 will never be in the lowest, and any given knight will never occupy six squares at the ends of the board. By pruning our domains now, we’ll reduce our potential search space from 36⁹ to 35² × 30⁷, which is a savings of over 76 trillion.¹
Since each constraint has the potential to prune the domains of the variables it affects, it makes sense to do this as a method of the Constraint class.

>     def prune_domains(self):
>         p1_domain, p2_domain = domains[self.p1], domains[self.p2]
>         p1_new_domain, p2_new_domain = set(), set()
>         
>         for v1 in p1_domain:
>             for v2 in p2_domain:
>                 if self.constr_fun(v1, v2):
>                     p1_new_domain |= set([v1])
>                     p2_new_domain |= set([v2])
> 
>         deleted = len(p1_domain) != len(p1_new_domain) or \
>                   len(p2_domain) != len(p2_new_domain)
> 
>         return {self.p1: p1_new_domain, self.p2: p2_new_domain}, deleted

Just having each constraint prune once isn’t enough of course, because one constraint’s pruning may have repercussions for the pruning of another. The naïve way to deal with this would just be to keep letting all constraints prune until the domains don’t change anymore. This is a valid way of doing things, and known as the AC-1 algorithm (for Arc Consistency).
Smarter might be to have a queue of all constraints, remove one, have it prune, and if it affects the domain, add all constraints involving the variables of the affected domains that aren’t already in the queue to the queue; repeat until the queue is empty. That one is AC-3. (Both are courtesy of Alan Mackworth, incidentally).
It doesn’t matter a huge deal which we use; because we don’t have an easy way of getting the constraints on a given variable, AC-3 is going to be slower than it has to be, to the point where it might even be slower than AC-1. We could deal with this, but it’s not worth it. Let’s just do something.

> def ac3():
>     queue = constraints[:]
> 
>     while len(queue) > 0:
>         c = queue[0]
> 
>         new_domains, d = c.prune_domains()
>         domains.update(new_domains)
> 
>         if d:
>             new_constraints = []
>         
>             for con in constraints:
>                 if (con.p1 == c.p1 or con.p2 == c.p1 or \
>                     con.p1 == c.p2 or con.p2 == c.p2) and con not in queue:
>                     new_constraints.append(con)
> 
>             queue = queue[1:] + new_constraints
>     
>         else:
>             queue = queue[1:]

Alright! Now that our affairs are in order, we can start with the algorithm in earnest. What we’ll be doing basically amounts to a depth-first search of the search space. We’ll need an unambiguous ordering of our pieces, so let’s convert our set to a list.
To keep track of our state, we’ll just use a dictionary that our algorithm will be modifying directly.

> pieces = list(pieces)
> z = {}

The search algorithm itself is really straightforward: we’ll fix a variable to a domain value, make sure it doesn’t violate any constraints, and then move on to the next variable. If it does violate a constraint, we move on to the next domain value. If we’re out of domain values, we move back to the previous variable and change that.

> def backtrack(depth):
>     for a in domains[pieces[depth]]:
>         z[pieces[depth]] = a
> 
>         for c in constraints:
>             if (c.p1 == pieces[depth] and c.p2 in pieces[:depth]) or \
>                (c.p2 == pieces[depth] and c.p1 in pieces[:depth]):
>                 if not c.valid(z[c.p1], z[c.p2]):
>                     break
> 
>         else:
>             if depth == len(pieces) - 1:
>                 print "Solution:", z
>             else:
>                 backtrack(depth + 1)

As written, this will just keep looking for solutions until it’s exhausted the search space, but it’s trivial to make it so that it stops after the first result is found, of course.

And that’s that. Now we just invoke everything and let it run.

> ac3()
> backtrack(0)

And we’re done!
As usual, all of the code can be found here, in case you want to try it yourself. If you want an exercise to try at home, find a sensible representation for the eight queens problem and solve that. (Hint: there’s a better one than (row, column).)

Now, is constraint processing a good alternative to the search tree algorithms previously discussed? Obviously not the algorithm I’ve just described; that’s just a naïve DFS without heuristics. It can be improved in a lot of ways: you could sort the list of variables so that the variables with the smallest domains and the most constraints affecting them are first, for example. Or you could go a step further and do dynamic search tree rearrangement using some heuristic, making sure that the variables more likely to cause a constraint violation are filled in first. You could prevent a whole lot of redundant checks using a variety of techniques, like backmarking or backjumping or intelligent backtracking or what have you; there’s a million things you could do.² There’s no shortage of research on constraint processing, and the state of the art is surprisingly advanced.
I’m not terribly fond of constraint processing algorithms, myself, because I get the impression that they’re more complex to implement for no significant gain, but I can see why some people would be.

In the end, the most significant factor is probably what the most natural way to express your problem is. Any problem that can be solved using vanilla search trees can be solved as a constraint problem and vice versa, but most problems are just easier to express one way or the other.

(My AI exam is on Monday, so this will probably be the last post in this series. The only course subject I haven’t covered is version spaces, anyway, and that’s not hugely interesting. Oh, and automated reasoning, but that’s more suited to a book than a blog post.)

⁰ Most algorithms only bother with two variables, but it’s entirely possible to formulate this problem as a single constraint on nine variables. Enforcing 9-consistency (see the domain pruning bit later on) would be equivalent to solving it the way we’re doing now, though.

¹ In fact, we’ll only look at a small fraction of that even when we do an exhaustive search, but any advantage is nice to have at this point.

² You could even use a language other than Python and implement it in a way that isn’t dumb!