We tag every release in a MAJOR.MINOR.BUGFIX format. 2.32.2 for example.

Recently I wanted to get a summary of the commit log messages for each of the tagged revisions. Here is the magic command that got me the output that I wanted:

# get all log entries for releases tagged with a 2.31 MAJOR.MINOR
hg tags | grep 2\.31 | cut -c33-36 | xargs -L1 hg log -r

cw

So last night I was going over the chapter that introduces ‘let’, ‘where’, ‘case’ and guards and I wanted to try them out. I contrived a simple situation where I thought I could use them.

I made some Contestants and wanted to see if they were “valid” for some definition of the word. I chose that they had to have a real value for age (not Missing) and be 30 years old or older (I’m pretty sure the game is called “Who Wants to Be a 30-year-old Computer Nerd?”).

Here is my implementation.

-- my parameterized type
data Perhaps a = Is a
               | Missing
                 deriving (Show)
 
-- definition of a Contestant
data Contestant = Contestant {
                    name ::  String,
                    age  ::  Perhaps Int
                } deriving (Show)
 
-- some contestants
contestant1 = Contestant "Christian" (Is 31)
contestant2 = Contestant "Sarah" Missing
contestant3 = Contestant "Curtis" (Is 6)
 
-- the validation logic
contestantValid :: Contestant -> Bool
contestantValid c = 
    case age c of
        Missing      -> False
        Is true_age  -> oldenough true_age
            where
                oldenough a
                    | a >= 30 = True
                    | a < 30  = False
 
-- some code to print the results of running the validation against contestants
main = do
    print $ (contestant1, contestantValid contestant1)
    print $ (contestant2, contestantValid contestant2)
    print $ (contestant3, contestantValid contestant3)

I was pretty proud of myself. I used ‘case’, ‘where’ and guards (not to mention parameterized types - I reimplemented Maybe/Just/Nothing as Perhaps/Is/Missing).

But man, it seemed like a lot of code to do something simple.

As I was falling asleep I realized how I could simplify it. I could use pattern matching to easily handle the Missing case. It would also let me pull the age out of a Contestant with ease too.

Here is the contestantValid function updated to reflect that.

contestantValid :: Contestant -> Bool
contestantValid (Contestant _ Missing) = False
contestantValid (Contestant _ (Is age))
                                | age >= 30 = True
                                | age < 30  = False

Quite a bit simpler. I patted myself on the back. It was less fancy than the first version, but at least I had some guards in there.

Then it hit me. I didn’t need the guards.

contestantValid :: Contestant -> Bool
contestantValid (Contestant _ Missing) = False
contestantValid (Contestant _ (Is age)) = age >= 30

Well, so much for ‘where’, ‘case’ and guards. It sure is a boring function now, but I think the process of how I got there is interesting.

cw

For those of you who don’t know, PiCloud is a cloud computing platform for Python that aims to simplify the task of running code in “the cloud.”

cw

She was born this morning at 7:11am EST. She weighed in at 8lbs. 1oz. and is 19″ long. Mom and baby are doing well. I’m doing great!

cw

The Minimum Viable Tree House

A case-study in what not to do with your software project.

Beautiful Coroutines: Cooperative Concurrency in Python using Diesel

cw

Announcing Diesel!

cw

I started with light brown dusty dirt in a “flower bed”. It might have even been tainted with nuclear waste. Nothing grows in it. Ants prefer to make their nests in the concrete sidewalk adjacent to it.

So I started in on the dirt. What did I start in on it with? A real-deal pick ax. Oh. Yeah. I didn’t let up either. OK, I did let up, a few times in fact. That dirt was hard. Harder than the hands of any of the Cleveland Browns’ wide receivers. That hard.

After I was done with the pick ax, I started in with the shovel. I loaded the dirt into a wheel barrow. I pushed the wheel barrow into the woods. I dumped the dirt. I proceeded to iterate over these steps until at least a ton (weight) of the dirt was in a pile in the woods.

If I were a retired guy prone to exaggeration and I was watching me, I’m pretty sure I would have said “That guy must have hauled twenty, maybe thirty tons of dirt! He was speed shiftin’!”

Let’s take stock of the situation. In the front yard I have … less dirt. In the woods I have … more dirt. Aha, but also in the woods, I have my secret weapon. An even bigger pile of leaves, from last fall. They have been lying in wait, decomposing, for just such a moment as this.

Now I haul wheel barrows full of dirt/decayed leaves to the front. Load after load. Iterations. Piles of dirt/decayed leaves. I spread the dirt/decayed leaves in the “flower bed”.

It used to be light brown, almost sand colored. Now it is brown like coffee grounds - or decomposed leaves - and it is enriched.

cw

There was no answer.

Though drenched with sweat, the summer heat was no match for the desperation of a father for his son. Racing through the field, the leaves on the cornstalks met Gustavo’s skin like slender green blades. He didn’t even notice the pain as he closed the gap between himself and where he had last seen his son.

As he burst free from field where he toiled, he nearly toppled over the children. Julio’s playmates were frantic. Tears streamed down their faces carrying the the dust of the pasture from their eyes. Gustavo hardly halted for a second.

He had already heard their cries from a long distance off, and he had heard the cry of his son.

The pasture wasn’t far now. Gustavo’s heart filled with a mixture of fear, love and rage as his eyes settled on the dark shape ahead beside the fence row.

Cavernous black eyes laced with red veins met the eyes of the overwhelmed father. The now giant bull that he had raised from a calf stood above the limp, bloodied figure lying in the dust.

…

“Father!”

The cry was one of desperation. The thunder of the hooves behind him surely drowned out his small voice. He glanced to his right and for a brief moment felt relief at the sight of his friends sliding under the fence to safety.

“This shouldn’t be,” the primal thoughts that raced through Julio’s mind told him. The animal must have broken free from its paddock and entered the previously empty pasture that was the children’s playground for the day.

It happened suddenly. The great horn hooked his light frame and sent him hurtling through the hazy air. The scene of the pasture swirled around him. Then the crunch of his back against the fencepost and the taste of blood and dirt in his mouth.

Before he could recover the hooves and horns of the great beast met him with blow after crushing blow. No more cries he made, only the involuntary sounds of air being forced from his now-beaten body.

The pain blanketed him like the heat from the midday sun blanketed the countryside.

“I’m finished,” he barely thought as consciousness mercifully began to depart him. Darkness was closing in all around.

A terrible sound tore across the pasture and reached the ears of the fading child. It was familiar to him. Again it sounded, cutting through the darkness of his consciousness like a sickle through wheat. Rather than adding to his misery, the deafening sound comforted Julio.

His father had arrived.

…

Before the first shells were finished dancing in the dust near his feet, Gustavo unleashed another round upon the treasured animal, now turned murderer. It reared away in fear and pain and stumbled to the ground a short distance from the child. The nearby ground shook as the great beast fell to the dust.

Casting his weapon aside, Gustavo cleared the fence and was at once by the side of his son.

…

Julio felt the whole world begin to shake, as visions of the farm where he lived flashed before his eyes. With his final act of consciousness before slipping into the darkness, he realized that he was in the arms of his father, who was rushing him off to undoubted safety.

.

The other day one of the developers did that and one of our tests started failing. A simple change from:

class Foo:
    # stuff here

to:

class Foo(object):
    # stuff here

was all that happened.

Here is some code that encapsulates the problem and runs with some interesting results:

"""Two nearly identical classes with quite different behavior."""
 
class LameContainerOld:
    def __init__(self):
        self._items = {'bar':'test'}
 
    def __getitem__(self, name):
        return self._items[name]
 
    def __getattr__(self, attr):
        return getattr(self._items, attr)
 
class LameContainerNew(object):
    def __init__(self):
        self._items = {'bar':'test'}
 
    def __getitem__(self, name):
        return self._items[name]
 
    def __getattr__(self, attr):
        return getattr(self._items, attr)
 
if __name__ == '__main__':
    for cls in [LameContainerOld, LameContainerNew]:
        container = cls()
        print "Testing", cls
        try:
            'foo' in container
        except Exception, e:
            print "\tMembership in %s raised %r!" % (container.__class__, e)
        else:
            print "\tMembership in %s worked!" % container.__class__
        print "\t%s" % container.__getitem__

Here is some output from running that:

Testing __main__.LameContainerOld
        Membership in __main__.LameContainerOld worked!
        <bound method LameContainerOld.__getitem__ of {'bar': 'test'}>
Testing <class '__main__.LameContainerNew'>
        Membership in <class '__main__.LameContainerNew'> raised KeyError(0,)!
        <bound method LameContainerNew.__getitem__ of <__main__.LameContainerNew object at 0xb7d1c1ac>>

From what I can tell, when a membership test happens on the old-style instance, a membership test is done on self._items and it returns False. When the membership test happens on the new-style instance, it tries to treat it like a sequence and calls the __getitem__ method with index 0.

Does that seem like a correct analysis? Does anyone know why the behavior is different there?

Also look at the output for printing container.__getitem__. Isn’t __getattr__ only supposed to be called when the attribute isn’t present on the instance? Why does it return the __getitem__ method of self._items for the old-style instance then?

Very puzzling.

cw