book review: Tempo

Venkatesh Rao.
Tempo: timing, tactics and strategy in narrative-driven decision-making.
Lightning Source. 2011

---

Life is a verb, not a noun.
— Charlotte Perkins Gilman

Despite Gilman’s aphorism, people seem much more able to think in terms of things rather than actions, stuff rather than change, objects rather than processes. This may be because, as Mark Bickhard points out, we have a substance metaphysics, but no acceptable process metaphysics. Rao’s slim book (150 pages in total) goes some of the way to providing the latter for our social environment.

Rao starts from the idea of process, of a sequence of events, and goes from there, to bring in the concept of time. His time is not merely an ordering of events, but is a measure of the rate, of the tempo, of those events. Understanding the tempo of the various processes, and how these interact, and interweave, is the basis of his discussion of decision making, from individual cooking to multi-person businesses.

Understanding the dynamics of the decision-making process exposes various phenomena that can be part of the process. Rao identifies fait accompli, brinkmanship, procrastination, second-guessing, passive aggression, time-outs, defaulting, and building mindshare, among others.

We constantly need to make decisions, and those decisions need to be situated in the current context. Context switching includes gaining situational awareness (grokking where things are and what they are doing, now and in the near future) in the new context. Situational awareness crucially includes awareness of the situation’s tempo.

p115. The major claim in this book is that tempo can be used to modulate enactments that move along too quickly to manage one micro decision at a time.

Once you have an awareness of the tempo, you can modulate it to improve your performance, either in competition, or cooperation, with others in the environment.

p118. The primary effect of operating at a faster tempo is that you can maneuver inside the decision cycle of your opponent, disrupting his or her enactment …
    This style is obviously effective in adversarial settings, but it is equally effective in cooperative settings …. The alert waiters at upscale restaurants, fulfilling your needs before you even recognize them, are a good example.

The situations we encounter are not arbitrary. They may have a greater or lesser degree of legibility to us, and we modulate our environment to control situations and their legibility. Rao explains how we do this. We comprehend the world through mental models, and we organise the world to externalise these models. This organisation, this modulation of our environment helps us improve our efficiency, our ability to perform.

p127. To externalize a mental model is to arrange our physical environment to serve our intentions more efficiently. In cognitive psychology, this idea is called distributed cognition.

The full process of organisation is a combination of objective and deliberative design and of participatory dance dependent on situational awareness and tempo; how much of each component we use depends on circumstance and preference.
Different styles of decision making follow different patterns; Rao identifies reactive, deliberative, opportunistic, and procedural. For example, a procedural, or bureaucratic, style has the environment organised by another, so that you can follow a codified process without necessarily understanding it, yet still achieve the desired outcome.

Civilisation advances by extending the number of important operations which we can perform without thinking about them.
— Alfred North Whitehead

Following such an opaque procedure can be very efficient, because you do not need to think so deeply, but if the context deviates from that assumed by the organiser, you cannot then readily modify what you do not understand.

On the other hand, our personal, efficient organisation of our environment has meaning to us. This meaning may be legible to others, or it may not. If we wish to organise in concert with others, we need to be legible to them, but this might impact our own efficiency. Bosses who demand tidy desks are prioritising their own need for legibility, for control, over their staff’s efficient meaningful organisation.

Central planners can have the same desire for control, but this can kill the very thing they are trying to create.

p133. … central planners begin by poorly internalizing a rich, emergent collectively externalized mental model (such as the structure of an old city). They proceed inevitably to failure when they attempt to replace it with the externalization of their own impoverished mental models, constructed largely out of primitive platonic ideals, a case of design destroying dance.

Nouns and verbs tend to focus on single specific things. Rao lifts these concepts into the environment, as fields and flows.

p138. Fields are arrangements of the physical environment. Flows are the behaviors that result when humans interact with a field. Flows are the observable parts of others’ enactments.

Rao is not concerned with a general model of all physical reality here, but with an approach to situated decision making, of people in social environments.

p139. For a given individual, the environmental field … combines with the other group members in the field at the same time, to create a social field. When there is little momentum or meaning in the primary environmental field, the dynamics of the social field start to dominate. An environmental field that is deliberately designed to catalyze complex social behaviors generally contains one or more social objects…. Chairs and tables are among the simplest social objects.

Unlike the models and processes imposed by central planners and rigid bureaucrats, Rao advocates a balance between the aspects of design and dance.

p141. Artistic approaches to field-flow complexes exploit the natural chemistry among mental models in richer ways. The key to such approaches is a tasteful blending of preparatory design and participatory dance. Successful field-flow complexes can neither be designed nor danced into existence. They must be orchestrated. A conductor or choreographer, rather than a pure designer or dancer, is necessary.

The metaphor of conductor or choreographer, rather than the extremes of rigid pre-programmed design, or of completely fluid and potentially chaotic dance, is interesting. Denis Nobel uses a similar metaphor to explain biology. It seems to be a metaphor well-suited to a variety of complex systems.

Complex systems comprise a collection of agents interacting in and with a complex environment. For a single agent, its environment comprises not only the organised spaces, but the other agents, too. In Rao’s model, the agents are people making their context-dependent situated decisions.

p143. Groups cannot be realistically studied unless you take into account the effects of the field-flow complexes that they inhabit. This is a natural consequence of narrative rationality: you can only understand a group with reference to the specific narrative within which it is situated.

That is, the same group of people in a different environment, or even in the same physical environment in a different context, will behave differently. This should not be at all surprising, but the environment and context are often neglected in complex systems analysis in order to simplify the problem; just think of in vitro versus in vivo experiments, or many experiments performed in psychology labs.

Rao demonstrates how a consideration of tempo, situation and context, and of patterns of decision making, can illuminate many more patterns than the standard procedural bureaucratic one. Moreover, these other patterns and metaphors have distinctly different flavours, especially when applied to changing an organisation.

p144. Where change in the machine metaphor is a process of stepwise re-engineering, in the other, more organic metaphors, change is a process of generative growth, ontogeny and self-organization.

This book nicely complements a lot of books trying to apply complexity theory to organisations. Here Rao focuses on complex human systems, involved in descion making, aspects often missing from the more theoretical models of complex systems exploited by the other approaches.

This deserves rereading. Some of the earlier discussions, which can have a slightly hippy-Zen flavour (despite many examples being from military command and control) take on more meaning in light of the later application. Recommended.

---

For all my book reviews, see my main website.

sequestering carbon, several books at a time XX

A few more join the hordes:

spring

It’s hard to believe that this time last year was freezing cold, and snow.  This year is a little different.

catkins in sun and shade

luminous crocuses

It’s not just the vegetation.  The frogs clearly think it’s spring, too.

my Trello backup code

Back in August I blogged about Trello, a great browser-based list manager.  I’ve been using it constantly ever since. I use Evernote to manage the past, and Trello to manage the future.

In that Trello blog post, I mentioned I written a bit of Python to backup my boards. Yesterday PK asked in a comment for that code.  I thought briefly of putting it up on something like GitHub, but the code is so short, I decided I’d give it here instead.

I also thought about refactoring the code a bit first.  I wrote this a while ago, and I know a bit more Python now.  But it works.  So I’ll leave any refactoring until I have to make some changes.  (Well, okay, maybe I made a few changes to remove the worst uglinesses…)

First, there are some libraries to import.

import json
import unicodedata
import urllib2
import datetime

I strip the unicode out of the Trello data, for simplicity.  (One day I will spend the time to really understand all the intricacies of unicode in HTML, but for now, out it goes.)  As usual, Stack Overflow was of invaluable help in finding a way to do this.

def stripUnicode(ustr):
    # translate unicode (accents) to non-accented chars
    ustr = unicodedata.normalize('NFKD', unicode(ustr))
    ustr = u"".join([c for c in ustr if not unicodedata.combining(c)])
    
    # translate whole string to ascii
    return ustr.encode('ascii', 'ignore')

The overall structure of the code is simple: loop over the boards; for each board, print an HTML header, print the lists (which involves printing their cards), then print an HTML footer.

The HTML header involves a title, importing the CSS style file, and a bit of stuff to control the width (a fudge, frankly, but this is for me, not general purpose code!).

def print_header(fhtm, board, lists):
    print >> fhtm, '<html>'
    print >> fhtm, '<head>'
    print >> fhtm, '  <title>' + board['name'] + '</title>'
    w = len([lst for lst in lists if not lst['closed']])*318
    print >> fhtm, '  <style type="text/css">'
    print >> fhtm, '    @import url(trello.css);'
    print >> fhtm, '    body {min-width: ' + str(w) + 'px;}'
    print >> fhtm, '  </style>'
    print >> fhtm, '</head>'
    print >> fhtm, '<body>'

Printing the lists involves looping over the lists, and for each open list printing a heading, and printing the cards in the list.

def print_lists(fhtm, lists, cards, checklists):
    for trello_list in [lst for lst in lists if not lst['closed']]:
        print >> fhtm, '<div class="list">'
        print >> fhtm, '<H2>' + trello_list['name'] + '</H2>'
        print_cards(fhtm, cards, checklists, trello_list['id']) 
        print >> fhtm, '</div>'

Printing the cards involves looping over the list of cards, and for each card, printing its due data, description, and checklists (including strike-through for completed items).  There is potentially more information in a card, but that’s all I currently use.  If you use more, you will have to update this bit, but the structure of what’s needed is fairly obvious.

def print_cards(fhtm, cards, checklists, id_list):
    for trello_card in [c for c in cards if c['idList'] == id_list]:
        print >> fhtm, '<div class="card" >'
        print >> fhtm, '<H3>' + stripUnicode(trello_card['name']) + '</H3>'
        print_card_due(fhtm, trello_card)    
        print_card_desc(fhtm, trello_card)    
        for id in trello_card['idChecklists']:
            print_checklist(fhtm, checklists, id)    
        print >> fhtm, '</div>'
    
def print_card_desc(fhtm, card):
    if card['desc'] != "":
        print >> fhtm, '<P>' + stripUnicode(card['desc'])
        
def print_card_due(fhtm, card):
    if card['due']:
        print >> fhtm, '<UL><LI type="square"><I>due</I> ' + card['due'][:10]
                     + '</UL>'
        
def print_checklist(fhtm, checklists, id):
    checklist = [c for c in checklists if c['id'] == id][0]
    print >> fhtm, '<H4>' + checklist['name'] + '</H4>'
    print >> fhtm, '<UL>'
    items = checklist['checkItems']
    items.sort(key=lambda x: x['pos'])   # pos = screen posn, for list order
    for item in items:
        print_checklist_item(fhtm, item)
    print >> fhtm, '</UL>'
    
def print_checklist_item(fhtm, item):
    if item['state'] == "complete":
        print >> fhtm, '<LI><I><DEL>' + stripUnicode(item['name'])
                     + '</DEL></I>'
    else:
        print >> fhtm, '<LI type="circle">' + stripUnicode(item['name'])

The HTML footer is trivial.

def print_footer(fhtm):
    print >> fhtm, '</body>'
    print >> fhtm, '</html>'

There are some secret keys and tokens needed, which you get when you register at Trello, to get access to your own boards.

key = 'a 32 hexdigit string'
token = 'a 64 hexdigit string'

I have hardwired in the various boards I want to backup. The 24 hexdigit string can be found right at the beginning of the board’s JSON file, so you have to download that manually, and copy the string from it. But you only have to do that once.

board_dict = {
    'board1': 'a 24 hexdigit string',
    'board2': 'a 24 hexdigit string',
    ...,
    'boardn': 'a 24 hexdigit string'
}

Then, finally, there’s the loop over the boards in this dictionary: reading in the board data, which requires reading the board, its lists, its cards, and its checklists separately, then printing out the relevant HTML, including the date of the backup:

for filename, board_id in board_dict.iteritems():
    print filename
    
    trello = 'https://api.trello.com/1/boards/' + board_id
    key_token = key + '&token=' + token

    get_url = urllib2.urlopen(trello + '?key=' + key_token)
    board = json.loads(get_url.read())
    get_url = urllib2.urlopen(trello + '/lists?key=' + key_token)
    lists = json.loads(get_url.read())
    get_url = urllib2.urlopen(trello + '/cards?key=' + key_token)
    cards = json.loads(get_url.read())
    get_url = urllib2.urlopen(trello + '/checklists?key=' + key_token)
    checklists = json.loads(get_url.read())

    fhtm = open(filename + '.htm', 'w')
    print_header(fhtm, board, lists)
    print >> fhtm, '<H1>' + board['name'] + ' (' + str(datetime.date.today())
                 + ')</H1>'
    print_lists(fhtm, lists, cards, checklists)
    print_footer(fhtm)
    fhtm.close()

Then to get this to format looking a bit like a Trello board, we just need a bit of simple CSS for the list and card classes used above:

.list {
  margin: 0 3px 1em 3px;
  padding: 0 4px 4px 4px;
  background-color: #eee;
  border: 1px #aaa solid;
  border-radius: 4px;
  float: left; 
  width: 300px;
}

.card {
  margin-bottom: 4px;
  padding: 0 0.6em 0 0.6em;
  border: 1px #aaa solid;
  border-radius: 4px;
}

I’ve also modified the various headings styles to make things look nice, but I’ll leave that as an exercise for the student!

Python makes writing this kind of stuff so straightforward.  It took me far longer to work out the JSON format and API of the Trello stuff than to write the code.

If I was writing this today, I might think about using an library like Beautiful Soup, or, given how straightforward it was, I might just do it this way again.

what a difference a month makes

The end of another month, and so we have solar stats for February now.  In the chart below, time runs along the x-axis, number of kW being produced up the y-axis.  The black line is the energy generation on that day.  The orange background shows the minimum, quartile, median, and maximum values, averaged over the month.

These February stats compare interestingly with the stats for January:

These carts are plotted with the same horizontal and vertical scales.  The February averages are very noticeably wider (longer days) and higher (sunnier days) than January.  And we aren’t even yet at the point where the day length is changing fastest – at the equinox, in March.

A different view shows all the days on a single plot.  Time during the day runs along the x-axis; days run up the y-axis; the colour represents the amount of kW being generated at that time, on that day.

This clearly shows how the days getting longer, too.  I look forward to seeing what March brings us.

All the up-to-date charts can be found on my other web site.

sequestering carbon, several books at a time XIX

Hardly enough to be worth mentioning, but here is the latest lot:

a surfeit of packaging

My phone started behaving strangely over the weekend: switching off for no reason, then claiming the battery was dead, but when I plugged it in to the charger, claiming the battery was half, then fully, charged.  After some searching on the web, I discovered this probably meant the battery was pining for the fjords.  Maybe not that surprising: it is 2 and a half years old, and has been maxed out on certain games at times.

More hunting on the web, and I found a place selling genuine Samsung batteries (as opposed to much cheaper batteries that the reviews seem to think are rip-offs) at eye-watering prices (I shouldn’t be surprised at the price, I suppose; I recently bought a new battery for my watch, and previously a new strap: the combined price was more than that of the original watch).  I ordered one; it arrived promptly today; the phone is now fine.  I have my life back.

Phone batteries are small and compact, so I was expecting a small parcel.  I received the battery in a plastic wrapper, in a jiffy bag, in a plastic envelope:

a lot to recycle…