Brian Beck’s Text Adventure

Days 1-4: Cleveland to Ann Arbor

Wed, 18 Aug 2010 21:24:00 -0400

Friends and family met us at Lakewood Park on Sunday to send us off—two days later than we originally planned.

We finally hit the road a little after 3pm, but stopped at Century Cycles in Rocky River for some last minute supplies.

The ride to Oberlin was slow, but we made it. It took us quite a few miles to get used to the weight of the bikes—each carrying about 50 pounds.

There weren’t many people on campus at the time, so we just picked up some Chinese food and started scouting out a good spot to set up for the night. We settled on a hidden clearing next to a chapel and unloaded our gear.

That turned out to be a terrible idea. For one thing, the bells tolled every hour—even at 2am. And the benches around the corner turned out to be a popular late-night hangout for students looking to drink on the down-low. After the second rowdy group left, I gave in and looked up the closest motel. At 3am, we quickly packed it up and rode to the motel in the dark of the night. This turned out to be my favorite few miles of riding so far. The air was cool, there was absolutely nobody on the road, and we could only see as far as the reach of our headlights.

After showers and breakfast at the motel on Monday, we left for Fremont, Ohio.

Unfortunately, we didn’t discover the North Coast Inland Trail until we arrived in Fremont, so the ride could have been faster and easier than it was. While looking for a place to camp, we found the trail and met a new friend: John, a 26-year-old mechanical engineer contracting on a project in Fremont. After sending us off with suggested camping locations, he caught up to us and offered his place for the night. We gladly accepted and ended up having a great time.

The next morning we hopped on the trail and enjoyed another day of perfect weather. We ran into Elmore Cycle & Fitness along the trail and stopped in for some tune-ups on Erin’s bike. The head mechanic, Mike, was interested in the gear we chose to pack and eagerly offered some helpful advice (such as picking up 12oz of heat antifreeze at a gas station to replace the 32oz of denatured alcohol we’re carrying for cooking). Mike posts photos of passing tourers and his ultralight setups on his Flickr stream (photos of us coming soon).

We eventually reached and promptly exited Toledo, which had terrible roads for cycling and the worst drivers. Everyone had some stupid comment for us—none of them demonstrating any knowledge of the actual rules of the road, of course. So we rode until we reached Temperance, Michigan, and found the perfect stealth camping spot behind some trees.

This morning was the earliest we’ve started yet, waking up at 7:00 to make breakfast and pack up, and hitting the road by 9:00. After 15 miles, we took a short break in Dundee, which was home to every imaginable fast-food chain on just a half-mile stretch, but also a cute and clean downtown area.

The remainder of the trip was spent riding directly north on some very sparsely populated roads, singing songs and taking pictures along the way to cure our boredom.

We rolled into Ann Arbor a little after 1pm and met up with our friends, Erin and Bryan (funny, right?) at their apartment. We’re about to leave for the bar to see their band Lake Folk perform. We’ll be taking advantage of these comfy couches tonight and leaving for Kalamazoo after lunch tomorrow!

Bike Adventure Gear, Part 1: Camping

Fri, 06 Aug 2010 02:12:00 -0400

Over the next few days, I’ll be posting all the gear Erin and I are bringing on our bike trip to Seattle. I’m a determined comparison shopper and bargain hunter, so every last item here was meticulously researched, and we got great deals on almost everything. Maybe these posts will save you some time if you’re planning a similar adventure!

Today’s post: our camping gear.

We’ll be spending our nights in The North Face’s Big Fat Frog 2-person tent:

One of the highest rated tents on REI, I bought it there during their big sale earlier this summer, and saved some money by purchasing the footprint from Rock/Creek.

Since our bodies will likely be aching after riding for hours every day, we each have our own REI Trekker 1.75 self-inflating sleeping pad. To save on weight and space, we’re only bringing one sleeping bag, replacing the other with a Cocooon ripstop silk liner. We can always share the sleeping bag if necessary, so I’m betting that this tradeoff is going to be worthwhile.

We’ll be cooking our meals on the road with the Mini Trianga 28-T backpacking stove:

This tiny stove burns denatured alcohol and comes with a pot and pan. While we’ll mostly be using this just to boil water, I’m looking forward to learning how to cook meals as quickly and efficiently as possible with this limited equipment. CampSaver.com had the best deal on this stove.

And why bring along some normal household utensils when we can use the Guyot Designs MicroBites and the Snow Peak titanium spork? If there’s an everyday item that has a fancy backpacking equivalent, I had to have it. :)

For campsite lighting we have the Black Diamond Orbit lantern and the Mammut TR1 headlamp:

Both are super bright. Unfortunately, Steve’s dog chewed up the lantern, which does in fact resemble a dog toy. It still works fine - a testament to its durability, at least. Oregon Mountain Community had the best deal on the headlamp.

Other miscellanous items…

A couple MSR PackTowl compact and lightweight towels.
A firesteel, so I can struggle to ignite things until Erin gets frustrated and uses her lighter.
This coffee pot - Erin’s vice, not mine. You’re responsible for carrying this one, Erin!
Plates, bowls, stove fuel, soap, and a clothesline.

Think I’m missing something? Help me out in the comments!

In my next post, I’ll write about the most important gear - our bikes and accessories.

The State of the Weblog

Fri, 30 Jul 2010 18:37:48 -0400

My media server is down, so some content may be missing (pictures, linked documents), and I’m using a temporary theme.

My last day of work in Cleveland is one week from today. The week after that I’ll be riding my bicycle to Seattle with my girlfriend, camping and couchsurfing on the way. It’ll take us about five weeks, and I’ll be posting frequent updates here. Hopefully our cycling adventures capture your interest as much as code and Cleveland musings.

Follow if it is adventure that you seek…

Serious Games talk at Case

Mon, 12 Apr 2010 21:49:00 -0400

I’ll be giving a talk on serious games at the next meeting of the CWRU Hacker Society on Wednesday, April 14th, 8pm in Glennan 313.

The scope will be much wider than my previous talks on Unit Testing Achievements. A rough outline:

What are serious games?
How can they be applied to software?
How do they affect behavior?
What’s out there now?
What’s left to be explored?

See you there!

Achievement Unlocked

Wed, 24 Feb 2010 12:08:00 -0500

[This post is adapted from a lightning talk I gave at the Testing in Python Birds-of-a-Feather session at PyCon 2010.]

One of those most fun advancements in video games in recent years is not about the improved graphics, or playing with hundreds of people at once. It’s that games have evolved beyond points. While a good point system may be a good indicator of a player’s abilities, it doesn’t tell the whole story. Many modern games, even if they don’t involve points, have introduced the concept of achievements. Achievements are awarded for completing game-specific challenges—essentially, they are merit badges.

Examples

From Team Fortress 2:

From The Beatles: Rock Band:

From foursquare:

These add another level of fun to the games in question. I think it’s about time we stole this idea for software testing.

Testing Achievements

To make this happen, I announced an Achievements plugin for nose, the Python test runner. Here are a few highlights:

Night Shift
Make a failing test suite pass between midnight and 5am.

Punctuality
Make a failing test suite pass at 9am.

Coffee Break
The test suite takes between 5 and 15 minutes to run.

Happy Ending
All tests in the suite fail…except the last.

My God, It’s Full of Dots
The suite has at least 2,001 passing tests.

Sausage Fingers
At least two distinct syntax errors are raised by the test suite.

Are You Mocking Me?
Import a mocking library.

100% Code Coverage, Level x
100% of at least 2^(x+7) statements are executed.

You can view the full list of achievements here. Many of these are working right now.

Next Steps

Announcing unlocked achievements on Twitter or IRC, global or project-specific leaderboards, pluggable achievement expansion packs…

Share your ideas in the comments!

Phaeton by Kevin Cornell & Randy Jones. This typeface really...

Fri, 22 Jan 2010 11:03:23 -0500

Phaeton by Kevin Cornell & Randy Jones. This typeface really stood out in ILT’s favorites of 2009. Love it!

Emergency party at my place

Wed, 11 Nov 2009 00:56:00 -0500

Dear Reader,

You knew keeping this blog in your RSS reader would pay off one day, didn’t you? You did, right?

Well now you can reap the rewards, my friend. There comes a time.

You are invited over to my house on Friday, November 13 for a party and performances by several talented musicians.

There will be a full bar. Also an actual, physical bar. Celebrated Clevelander Marta “Martender” Lapczynski will be bartending.

We’re getting started at 10 PM; music at 11. Everything is free.

Here’s your invitation with the details:

See you there, Internet lovelies!

“The Cleveland Tourism Board gave me 14 million dollars...

Fri, 17 Apr 2009 10:55:19 -0400

“The Cleveland Tourism Board gave me 14 million dollars about 8 months ago to make a promotional video to bring people to Cleveland. As usual, I waited till the last minute and I ended up having to shoot and edit it in about an hour yesterday afternoon.” — bishopvids

Cleveland Code Co-op meeting on Sunday

Thu, 19 Feb 2009 15:55:53 -0500

The fifth meeting of the Cleveland Code Co-op will commence this Sunday, February 22, from 13:00 till 19:00. We’re expecting more participants than usual, and likely projects so far include:

redit, a text editor in Ruby
80sheep, an ADC (peer-to-peer) client in Python
a Python tutorial for beginners
your wildest software fantasies

This month’s meeting will take place in the EECS student lounge at Case Western Reserve University, which is located in the Glennan Building. Directions are located on the wiki. You can also join us on IRC in #C3 on irc.freenode.net.

Food and drinks will be provided! Hope to see you there.

Python instance descriptors: when class descriptors aren't dynamic enough

Thu, 29 Jan 2009 12:41:00 -0500

Python descriptors are great for customizing access to attributes on a class or instance. They are a big win for tasks like mapping Python objects to data from non-Python sources (such as SQL), since mapped attributes will need to be encoded/decoded and connected to other attributes in some way.

Below is a very simple descriptor; as you can see, accessing it from both the class and the instance invoke the descriptor protocol:

class Test(object):
    pass

class Descriptor(object):
    def __get__(self, instance, owner):
        return "Hello, world."

>>> Test.x = Descriptor()
>>> Test.x
'Hello, world.'
>>> test = Test()
>>> test.x
'Hello, world.'

However, in order to add descriptors to an object, they must be added to the object’s class. Descriptors added to an instance do not invoke the descriptor protocol:

>>> test.y = Descriptor()
>>> test.y
<__main__.Descriptor object at 0x16fe810>

This means that creating an instance with dynamic (determined at runtime) descriptors requires either the heavy-handed approach of generating a class just for that object (since adding descriptors to its class will add them to all other instances of the class), or the ad-hoc approach of redefining getattr/setattr behavior (essentially re-implementing your own descriptor protocol).

It turns out the latter approach is not as messy as it first sounds. Below is a class that enables “instance descriptors”:

class InstanceDescriptorMixin(object):
    def __getattribute__(self, name):
        value = object.__getattribute__(self, name)
        if hasattr(value, '__get__'):
            value = value.__get__(self, self.__class__)
        return value

    def __setattr__(self, name, value):
        try:
            obj = object.__getattribute__(self, name)
        except AttributeError:
            pass
        else:
            if hasattr(obj, '__set__'):
                return obj.__set__(self, value)
        return object.__setattr__(self, name, value)

class Test(InstanceDescriptorMixin):
    pass

>>> test = Test()
>>> test.z = Descriptor()
>>> test.z
'Hello, world.'

"The purpose of syntax highlighting is to turn your code into a map, not The Jimi Hendrix Experience."

Tue, 06 Jan 2009 15:29:26 -0500

“The purpose of syntax highlighting is to turn your code into a map, not The Jimi Hendrix Experience.”

geopy sprint at December C³ meeting

Sat, 13 Dec 2008 23:51:15 -0500

Today (Sunday) the third meeting of the Cleveland Code Co-op will be held from 1pm to 7pm at Gypsy Beans & Bakery. We’ll be focusing on geopy again, continuing our sprint goals from last time. All are welcome to attend. You can join us via IRC in #c3 on irc.freenode.net.

Christmas tree adventure

Sat, 13 Dec 2008 22:59:00 -0500

I’ve never taken the time to get a Christmas tree while living on my own before because, honestly, Christmas doesn’t mean much to me. But having moved into a spacious single-family carriage house with Steve, it sounded a lot more fun to drag a big needly tree into my living room this year. Today Mandy and I drove all the way out to Tower-N-Pines Farm to cut down our own tree. We followed this up with dinner at Mary Yoder’s Amish Kitchen, where Mandy told me everything she knows about the Amish (Middlefield has the world’s fourth largest Amish population).

I was hoping for an axe, but they only provided hacksaws. I then realized that, despite being cooler and more fun, an axe would have required blindly swinging your arms into the branches:

We did a lot of walking and probably looked at every single tree. This took a long time:

We settled on this one:

Finally, the moment I had been waiting for:

Mandy even got her chance to make this face:

It worked:

Note all the inferior trees in the background:

Then there was dragging:

We tied it to the roof of Mandy’s car using the rope from my grappling hook (farm’s ropes? $11). It arrived safely:

Steve made up for his non-participation by helping “unfell” the tree:

Real mature, Steve:

Steve guesstimates that the tree is “almost 10 feet” tall.

Roomba decided to take its docking station — originally...

Tue, 02 Dec 2008 16:44:03 -0500

Roomba decided to take its docking station — originally placed in a much more sensible location — for a walk.

geopy sprint at November C³ meeting

Tue, 04 Nov 2008 17:39:00 -0500

After suffering from over a year of poor maintenance, geopy is finally getting some love this month. A few other developers and I will be focusing on geopy at this month’s Cleveland Code Co-op meeting. We’ve come up with an ambitious todo list, including:

Merging pending patches (bug fixes, Python 2.3 support, accuracy support)
Adding unit tests
Reverse geocoding support (finding locations near a point)
Higher level Points and Locations (instead of tuples and strings)
Keeping up with third-party geocoder APIs (and hacks)
A “compound” geocoder for querying multiple geocoders (as fallbacks or for averaging results)
A parser module with support for geotagged documents (including the Geo microformat), ISO 6709, GPX files, etc.
Geohash encoding/decoding
A formatter module for pretty-printing coordinates, distances, and ordinal directions (think “south by southwest”)
setuptools entry points to support geocoder plugins and discovery

I think these features are in line with the “geocoding toolbox” goal of the project. While there are a lot of features there, I think geopy will still feel like a nice compact library.

Why does geopy deserve some developer attention? Because it’s being used in numerous interesting ways, including: directing robots at Carnegie Mellon University, calculating stream lengths for the U.S. Geological Survey, and updating address data for the Barack Obama presidential campaign.

We’ll be sprinting on Sunday, November 16th. If anyone would like to join us in person or on IRC, please get in touch!

Unstoppable Rocket pumpkin.

Thu, 30 Oct 2008 21:12:00 -0400

Unstoppable Rocket pumpkin.

Henry the degu. ♥

Tue, 28 Oct 2008 21:04:24 -0400

Henry the degu. ♥

Simple scheduled message queue (with threads)

Sat, 18 Oct 2008 10:53:06 -0400

Here’s a more flexible version of the message queue in my last post. This version uses the threading module instead of processing, so it has no dependencies. See the new example after the code.

"""
Simple message queue.

Messages are scheduled and processed in a single worker thread spawned
from the main process.  Thus, events are enqueued asynchronously, but
processed in a linear fashion.

"""
import time
import sched
from Queue import Queue, Empty
from threading import Thread


def delay_put(duration, queue, message):
    time.sleep(duration)
    queue.put(message)

def run_scheduler(scheduler):
    scheduler.run()

class Scheduler(sched.scheduler):
    def __init__(self, queue, handler, timeout):
        self.message_queue = queue
        self.handler = handler
        self.timeout = timeout
        sched.scheduler.__init__(self, time.time, self.delay)

    def delay(self, duration):
        queue = self.message_queue
        if duration > 0:
            # Spawn a process that will sleep, enqueue None, and exit.
            Thread(target=delay_put, args=(duration, queue, None)).start()
        try:
            message = queue.get(True, duration + self.timeout) # Block!
        except Empty:
            self.timed_out()
        else:
            if message is not None:
               # A message was enqueued during the delay.
                timestamp = message.get('timestamp', self.timefunc())
                priority = message.get('priority', 1)
                self.enterabs(timestamp, priority, self.handler, (message,))

    def timed_out(self):
        print "Timed out."

    def startup(self):
        print "Starting scheduler!"

    def shutdown(self):
        print "Scheduler done."

    def run(self):
        # Schedule the `startup` event to trigger `delayfunc`.
        self.enter(0, 0, self.startup, ())
        sched.scheduler.run(self)
        self.shutdown()

class MessageQueue(object):
    def __init__(self, handler, timeout=10, scheduler_class=Scheduler):
        self.queue = Queue()
        self.scheduler = scheduler_class(self.queue, handler, timeout)
        self.worker = None

    def enqueue(self, message):
        self.queue.put(message)
        if not self.working():
            self.start_worker()

    def start_worker(self):
        self.worker = Thread(target=run_scheduler, args=(self.scheduler,))
        self.worker.start()

    def working(self):
        return self.worker is not None and self.worker.isAlive()

>>> import time
>>> def my_handler(message):
...     print time.time(), message

>>> mq = MessageQueue(my_handler)
>>> for i in range(1, 10):
...     now = time.time()
...     mq.enqueue({'data': i, 'timestamp': now + i})

Starting scheduler!
1224341361.32 {'timestamp': 1224341361.2808199, 'data': 1}
1224341362.3 {'timestamp': 1224341362.2912149, 'data': 2}
1224341363.31 {'timestamp': 1224341363.2913051, 'data': 3}
1224341364.32 {'timestamp': 1224341364.2913489, 'data': 4}
1224341365.32 {'timestamp': 1224341365.291404, 'data': 5}
1224341366.3 {'timestamp': 1224341366.291467, 'data': 6}
1224341367.32 {'timestamp': 1224341367.291549, 'data': 7}
1224341368.34 {'timestamp': 1224341368.291626, 'data': 8}
1224341369.34 {'timestamp': 1224341369.2921841, 'data': 9}
Timed out.
Scheduler done.

Simple scheduled message queue in Python

Fri, 17 Oct 2008 17:02:00 -0400

Here’s a very simple message queue using Python’s sched module and processing (available as multiprocessing in Python 2.6). This lets you asynchronously schedule events to occur at a specific time. It would be very easy to modify this to process messages with a pool of workers, or use threading instead of processing. There is one thing I could use lazyweb’s help with: find places in the code where I need to use a lock or where I am ignoring these guidelines.

Update: Here’s a cleaned up version using threads.

"""
Simple message queue.

Messages are scheduled and processed in a single worker process spawned
from the main process.  Thus, events are enqueued asynchronously, but
processed in a linear fashion.

"""
import sched
import time
from processing import Queue, Process
from processing.queue import Empty


def delay_put(duration, queue, message):
    time.sleep(duration)
    queue.put(message)
    queue.close()

class Scheduler(sched.scheduler):
    def __init__(self, queue, handler):
        delayfunc = self.make_delay_func(queue, handler)
        sched.scheduler.__init__(self, time.time, delayfunc)

    def make_delay_func(self, queue, handler):
        def delay(duration):
            if duration > 0:
                # Spawn a process that will sleep, enqueue None, and exit.
                Process(target=delay_put, args=(duration, queue, None)).start()
            try:
                message = queue.get(True, duration + TIMEOUT) # Block!
            except Empty:
                print "Timed out."
            else:
                if message is not None:
                    # A message was enqueued during the delay.
                    timestamp = message.get('timestamp', time.time())
                    priority = message.get('priority', 1)
                    self.enterabs(timestamp, priority, handler, (message,))
        return delay

    def startup(self):
        print "Starting scheduler!"

    def run(self):
        # Schedule the `startup` event to trigger `delayfunc`.
        self.enter(0, 0, self.startup, ())
        sched.scheduler.run(self)

def handle(message):
    print "[%s] MESSAGE: %s" % (time.time(), message)

def run_scheduler(scheduler):
    scheduler.run()
    print "Scheduler done."

QUEUE = Queue() # Message queue.  Use `enqueue` to add messages.
TIMEOUT = 10 # Seconds for scheduler to wait for items in queue.
SCHEDULER = Scheduler(QUEUE, handle) # Message handler scheduler.
PROCESS = None # Process running the scheduler.

def enqueue(message):
    global PROCESS
    QUEUE.put(message)
    if PROCESS is None or PROCESS.getExitCode() is not None:
        # There is no scheduler process running; start one.
        PROCESS = Process(target=run_scheduler, args=(SCHEDULER,))
        PROCESS.start()

Here’s a usage example:

>>> import time
>>> enqueue({'data': 1})
Starting scheduler!
[2008-10-17 14:33:56.212] MESSAGE: {'data': 1}

>>> enqueue({'data': 3, 'timestamp': time.time() + 10})
>>> enqueue({'data': 2, 'timestamp': time.time() + 7})
>>> enqueue({'data': 4, 'timestamp': time.time() + 15})
>>> time.sleep(26)
[2008-10-17 14:34:03.221] MESSAGE: {'timestamp': 1224268443.219, 'data': 2}
[2008-10-17 14:34:06.217] MESSAGE: {'timestamp': 1224268446.215, 'data': 3}
[2008-10-17 14:34:11.225] MESSAGE: {'timestamp': 1224268451.222, 'data': 4}
Timed out.
Scheduler done.

>>> enqueue({'data': 5, 'timestamp': time.time() + 5})
Starting scheduler!
[2008-10-17 14:34:27.233] MESSAGE: {'timestamp': 1224268467.232, 'data': 5}
Timed out.
Scheduler done.

Cleveland Code Co-op

Wed, 15 Oct 2008 14:35:00 -0400

Cleveland Code Co-op:

This Sunday will be the first meeting of the Cleveland Code Co-op. Our goal is to contribute to a different Free Software project at each session, determined by the interests of those present. This Sunday will be a Django sprint. All are welcome to attend.