On The Psychology of Military Incompetence by Norman F. Dixon

Analysing a number of historical military disasters to find a common psychological pattern. Dixon shows how the structure of military training and promotion systems encourages a particular set of character traits, which have a tendency to lead to disaster. From memory I don’t think he uses the term “cognitive dissonance,” but that’s a significant part of the story (the book is cited in Mistakes Were Made (But Not By Me), which I also highly recommend). There are all sorts of bizarre anecdotes, that leave you wondering how these wackos were ever allowed to order other men into danger — like the commander who sent out a reconnaissance party then (presumably to avoid having to hear the bad news) moved his command post but didn’t tell anyone where he had moved it to.¹ Beyond these, though, the broad conclusions the author comes to are extremely relevant for anyone who wants (or doesn’t want but feels forced) to feel cynical about modern politics.

Like a Fiery Elephant by Jonathan Coe

The biography of BS Johnson, and both man and biography are fascinating. Johnson was an avant garde novelist, playing all sorts of weird games with structure. (One novel consists of loose chapters kept in a box: the reader should read the first one first and the last one last, but may order the rest as she chooses. In another, each chapter repeats the same action from a different perspective, and position on the page exactly corresponds to the passage of time, so that in each chapter the top half of the third page describes the same event.) He was also a fairly messed-up and sometimes highly unpleasant character. He upheld honesty as the most important measure of artistic merit² but he lived in a world of constant self-deception. (The title comes from a student description which he liked to quote. Coe points out wryly that it’s very likely, given Johnson’s figure and poor classroom relations, that the child simply misspelled “fairy”, a possibility which Johnson apparently refused to contemplate.) He had ominous mystical experiences which never come into focus in the biography: he referred to them in his private writings but always, writing for himself, with the substance of the experience taken for granted. He committed suicide, and Coe successfully makes you feel both compassion for the pain that drove him to it and fury at the stubbornness with which he brought much of that pain upon himself.

Besides the subject matter, the amazing thing about this biography is how faithful it stays to the ideals of its subject. Coe writes about Johnson, but also about the process of trying to write in a way that Johnson would approve. He is explicit about his own emotional reaction to Johnson’s various foibles, and when he admits he can’t present an unbiased picture he gives instead extracts from letters, notes, interviews and so on, with little or no comment. It is honest in the broadest sense: true to the facts about this conflicted and often unpleasant person, but rich with empathy and compassion for him as well. It is also an extended exploration of what honesty can and cannot be in writing, and an attempt to test Johnson’s own principles by putting them into practise.

The Naming of Names by Anna Pavord

You might think that a book about the ancient and medieval names for plants would be boring. You would be wrong. Firstly, the cultural history is fascinating: how what we would think of as modern, scientific standards for describing plants (mainly for their medicinal properties) have gone in and out of fashion from Ancient Greece through the medieval Islamic world to the beginnings of the modern Western scientific revolution (she ends the book with Linnaeus, since the success of his systematic taxonomy takes all the interesting variation out of the story). But what really makes this book a keeper are the illustrations. Pavord has an extensive collection of plant manuscripts, often richly illustrated, and she has got reproduction rights for many more:³ the book is packed with full-colour plates ranging from a hyper-realistic Dürer watercolour of an anonymous piece of turf to a stylised medieval mandrake complete with human-form root (although Pavord notes with approval that the artist has accurately rendered the structure of the flower heads and berries). There are so many illustrations, and many are so beautiful, that I would be tempted to buy a second copy to dismember, to frame the highlights and hang them on our wall. If that’s not a recommendation, I don’t know what is.

Notes:

1. No details or page references because I have misplaced the book, dammit. I think this one was during the Boer war.
2. Yes I’m oversimplifying enormously, but it does seem to have been his chief principle.
3. The text ends on page 402, and there are 158 plates: more double-page spreads have an illustration than don’t.

In Athens, a city with a population just slightly less than that of New Zealand, we managed to bump into someone we met last year on holiday. We played rebetiko with the members of Giouf and stayed in one apartment with a view of the Acropolis, and another with a pair of delightful kittens.

In Katerini, Olga’s mother fed me as implacably as always. We swam in the sea, three times. (Greeks seemed to think we were slightly mad, but the water, although not at summer temperatures, was perfectly pleasant to stay in for a half hour or so.)

We drove to Thessaloniki to play rebetiko, and got home again at six in the morning.

For the first of May we joined some dear friends for a massive barbecue. To my great regret I failed to get a photograph of Stathis, four years old, with a wooden dagger in one hand and a souvlaki in the other, alternating between angelic stares at the goings on and enthusiastic gnawing on the souvlaki. I did, on the other hand, get a video of a beautiful oud performance by a friend-of-a-friend, but I managed to take it in portrait. Coming once I figure out how to turn it upright.

We spent another night close to Thessaloniki, entertained by Karagiosi (shadow puppet theater) performed by an eight-year-old, and then by the same story in abbreviated form courtesy of his four-year-old brother. The day after we added another member to our family:

Jasmine, or Γιασεμή, the lafta or lavta

Her name is Γιασεμή, or Jasmine (pronounced something like Ya-se-mi), from this beautiful song. She is a lafta (or lavta), a Turkish instrument sometimes called the “politiko laouto” in Greece (“the lute of Istanbul”). My plan is to use her frets and simpler tuning system to learn to hear the intervals of makam theory (much more nuanced and beautiful than the simple semitones I grew up with), so that I can start playing them also on the (fretless) oud.

It seems like wherever we went I got job offers. Some of these were late-night wine-assisted affairs of the “I know some guys who do web programming from home, surely you can help them out?” kind, but there seem to be some real possibilities for the end of this year or beginning of 2013. Fingers most decidedly crossed on that count…

Finally we played one last rebetiko session with the Katerini crowd, and left (reluctantly) at two in the morning, just as the party was getting started, to drive to the airport for the flight home. Olga is now ensconced in front of the laptop watching the election results come in, and we’re already planning the summer holiday.

In the meantime, if you’re not already reading Auch on Water, you should be.

Also in the meantime, something we cooked up the other evening:

Our new business cards

The extremely observant may also notice a dearth of non-exercise-related posts hereabouts. The weeks have been fuller than usual lately: Buzzcapture is working up to a (beta) product release, and the Via Egnatia Group (which I joined a month ago or so, playing Irish bouzouki) had a couple of concerts (yesterday night at the Pianola Museum, which is an amazing place). I have some plots and plans, but experience tells me that if I promise them here they’ll never actually come to fruition, so I’d better not.

Python’s decorator syntax is an extremely lovely piece of incremental language design. It adds just a tiny bit of syntactic sugar to the language, but that sugar makes you think about structuring your code in ways that I (at least, and apparently plenty of other people) find extremely productive.

There are two sane ways to write a decorator:¹

def decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # do what the decorator does and...
        return func(*args, **kwargs)
    return wrapper
 
def decomaker():
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            # do what the decorator does and...
            return func(*args, **kwargs)
        return wrapper
    return decorator

The tl;dr of this article is: always use the second one.

That’s right, I’m saying you should write the version with more boilerplate, not less. The reason is very simple: the second form allows you to extend your decorator with keyword arguments, while preserving backwards compatibility with any code that doesn’t know about them. The first form, on the other hand, can only be extended by breaking backward compatibility and requiring all uses of the decorator to be updated.

Let’s work that through in a little example. Here are two implementations of a simple entry/exit logging decorator.

def log_entry_exit_bare(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        logging.debug('Entering %s', func.func_name)        
        try:
            return func(*args, **kwargs)
        finally:
            logging.debug('Exiting %s', func.func_name)
    return wrapper
 
def log_entry_exit_args():
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            logging.debug('Entering %s', func.func_name)        
            try:
                return func(*args, **kwargs)
            finally:
                logging.debug('Exiting %s', func.func_name)
        return wrapper
    return decorator

Now here’s some code that uses them:

@log_entry_exit_bare
def my_first_function(a=1000):
    for b in range(1, a):
        my_second_function(b)
 
@log_entry_exit_args()
def my_second_function(a=1000):
    for b in range(a, 1, -1):
        my_first_function(b)

All well and good. Only now, it turns out that what my_second_function does is important enough to merit an INFO log rather than plain DEBUG. Easily done:

def log_entry_exit_args(log_level=logging.DEBUG):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            logging.log(log_level, 'Entering %s', func.func_name)        
            try:
                return func(*args, **kwargs)
            finally:
                logging.log(log_level, 'Exiting %s', func.func_name)
        return wrapper
    return decorator
 
@log_entry_exit_args(log_level=logging.INFO)
def my_second_function(a=1000):
    for b in range(a, 1, -1):
        my_first_function(b)

Crucially, any other code that also uses log_entry_exit_args continues to work exactly as it did before.

I can’t work the same magic with log_entry_exit_bare. I can easily upgrade it to take an argument (rewriting its definition to match log_entry_exit_args), but then I’ll have to track down every place it is used in my code, and add () to each usage. If it’s in a library I’ve released into the wider world, everyone using that library will have to change their code for the next release that incorporates this change. (Or, more likely, I won’t ever make such a release.)

Let’s face it: if you care enough about code reuse to use decorators at all, you probably care about this kind of backwards compatibility too. So don’t get stuck with inferior decorating.

Notes:

1. There are less insane ways than I would have expected, because Guido in his wisdom followed a gut feeling and restricted the syntax of decorator expressions.

So it seems other people are enjoying Constellation Games; people who are even closer to its ideal demographic; people who actually make games. Which is why there now exists Gatekeeper: a game written by space aliens millions of years ago, which you can play in your browser.

I can’t say that you should read Constellation Games if you enjoy Gatekeeper. (In fact, if you enjoy actually playing Gatekeeper for more than a few minutes then I’m a bit worried about you.) But if Lek Stalker and Ruins Deluxe tickle your funnybone, check out the rest of the novel. (Also, it is dirt cheap.)

Notes:

1. I’m a sucker for microfiction and for reviews-as-fiction. Even with real computer games I have been known to let reviews, backstory and a bit of shoulder-surfing substitute for actually playing.

In [1]: array = [[1,2,3], [4,5,6], [7,8,9]]
In [2]: [ sum(col) for col in array ]
Out[2]: [6, 15, 24]

So far so good. Now suppose I want to take the squares of all the elements in array, and flatten the results into a single list. This looks to me like a natural way to do it:

In [3]: [ x*x for x in col for col in array ]

However, it is wrong. The result:

Out [3]: [49, 49, 49, 64, 64, 64, 81, 81, 81]

At this point I should insert a picture of a horse in a raincoat holding a cat or something similar.

Let’s try that one more time, for sanity’s sake:

In [4]: [ x*x for x in y for y in array ]
NameError: name 'y' is not defined

Wat?!

What’s going on is two distinct oddities of Python, which I have encountered in production code and debugged so that you don’t have to.

Firstly, loop variables leak into the surrounding scope.¹ It’s easy to forget this for list comprehensions, since they don’t overtly contain a loop, but they work just the same. In our example, the col variable that for x in col is using is actually the exit value of col in the previous list comprehension. If you were following along at home and didn’t do that first, trivial, comprehension (with sum(col)) then chances are you didn’t have col defined in your ipython session and you hit the error early.

Once we’ve got that far, it’s easy to see where the example went wrong: variables are introduced in a list comprehension left-to-right, not right-to-left, so for row in array for x in row is the correct order. We can get here also by mentally creating the nested lists the comprehension represents:

for row in array:
    for x in row:
        yield x*x

A comprehension lifts the yield line to the front but leaves the loops in the same order.

Still, I think my ordering is a more natural way to represent the expression I’m trying to capture in code. I had assumed that it came from my long-ago love affair with Haskell, but that’s actually not the case. The equivalent Haskell expression is:

let array = [[1,2,3], [4,5,6], [7,8,9]] in [ x*x | row <- array, x <- row ]

The order the variables appear in is actually just the same.

This doesn’t raise my hackles the way the Python version does, though. The Haskell code clearly distinguishes the pipe from the comma; the rule you have to know is, before the pipe sees (variables defined) after the pipe, and scope resolution for commas works left-to-right as usual.² The weird thing about the Python version is that for <something> in <somewhere> has different scope resolution rules depending on where it is: the first instance in a comprehension resolves the <something> in <somewhere>, but later ones cannot.

So there you go. A case where Python’s minimalist syntax, which usually I very much appreciate, seems to me to be taking things a bit too far. And (again, just my opinion) a good reason to avoid this kind of list comprehension construction completely. Although in this case the alternative, a wordy map-lambda and an esoteric sum, doesn’t make me any happier:

In [5]: map(lambda x: x*x, sum(array, []))
Out[5]: [1, 4, 9, 16, 25, 36, 49, 64, 81]

Notes:

1. All Python programmers should know this about the for loop, since it lets you query the final value of the loop’s variable after exiting the loop.
2. And the same rules apply elsewhere in Haskell, for instance when pipe is used for guard expressions.

Not much exercise, mind you: 20 minutes of yoga this evening. But more than nothing, ergo better than nothing.

“Nothing?” you ask, “but whatever happened to running, and to rowing?” What happened this week is that I got ill. (Possibly helped along by running, and sweating, for 50 minutes in a t-shirt. It’s not actually really summer yet, turns out.) Tuesday I felt under the weather and skipped rowing, and Wednesday I woke up unable to speak and stayed in bed all day.

I must admit that the illness card had thoroughly played itself out by the weekend, so I have only laziness to blame for not getting back into the saddle. (After my last run my legs ached for days. I’m reluctant to go through it again, although I know I should.)

In more positive news, coming Tuesday is the last rowing session for this block and I’ve signed up for twice a week in the following block (back to one-man boats, and I hope by the time it gets warm and Springy to be in a skiff).