I then noticed that all responses from the server were error 500s. The trace included in the email alert referred to the package name of the old auth backend. Did I miss something? Did the deploy fail?

I SSHed into the server and a quick check suggested that the deployment was successful, and that there were no references to the old auth backend.

The problem was that the auth backend my user had authenticated with was stored in the session. Once I had cleared the session table, the site was operational again.

Thursday July 22nd. With registration starting at 10am and the first speaker at 10.30.

Where

National College of Ireland, Mayor St, IFSC, Dublin 1.

How much

FREE.

More details

Watch and listen to the expert:

by the dot conf

The previous code didn’t handle dependency cycles gracefully, and the type handling was verbose. I believe I’ve fixed these issues now, and 0.5 will be the baseline for future work.

0.5 wasn’t just about better implementation of the existing features. It also introduces some new features like the compound keys mentioned earlier.

One of the features I’ve added is proper support for __getattr__. The previous support was limited to top-level keys, but the keys can now descend the configuration to any level.

config_json = """
{
    "person": {
        "name": "John",
        "address": {
            "town": "Dublin"
        }
    }
}
"""
config = Config(config_json, restricted=False)

# in 0.4 you could do config.person['name']
"John" == config.person.name

# you can also use __getitem__
"Dublin" == config['person']['address']['town']

0.5 supports the use of compound variable keys to reflect the __getattr__ functionality.

...
    "nick": "${person.name} - ${person.address.town}"
...
"John - Dublin" == config.nick

Expression support is now explicit, to give more control to the configuration author. Expressions can be nested.

config_json = """ 
{
    "a": 10,
    "b": 20,
    "c": "{{ {{ ${a} * 5 }} + ${b} }}"
}
"""
config = Config(config_json)
10 == config['a']
20 == config['b']
70 == config['c']

Detection of variable dependency cycles is more complete, and I haven’t managed to sneak anything past it yet (I haven’t been trying any harder than the unit tests though). The check is performed up-front when parsing the configuration.

config_json = """
{
    "a": "${c}",
    "b": {
        "d": {
            "e": "${a}"
        }
    },
    "c": "${b}"
}
"""
try:
    config = Config(config_json)
except KeyError:
    """Cycle detected"""

That’s about it I think. The release is available on PyPI and GitHub.

I have added support for comments (multi-line and in-line) to configpy, therefore if a configuration has comments it is not JSON. Internally, configpy just strips the comments before parsing.

Here’s a brief example:

config_str = """
/* We can use single line */
/* and multi-line
   Javascript like comments */
{
    "var_a": "AAAA", // or simple in-line comments too
    /* we can mix comments everywhere */
    "var_b": "You must escape \/* slashes in name or value strings *\/",
    "var_c": "A longer string \/\/ like this one"
}
"""

config = Config(config_str)
assert "AAAA" == config.var_a
assert "You must escape /* slashes in name or value strings */" == config.var_b
assert "A longer string // like this one" == config.var_c

You can grab this release from PyPI.

configpy-0.2 (PyPI) has seen some big changes, the biggest of which is a change to JSON for the configuration format. There is also new expression support, with an unrestricted mode (full access to globals()).

The reason I dislike shutting the machine down is the time it takes to setup my development environment each morning. This dislike is nothing compared to the grief I give myself for wasting electricity.

The decision was simple, I needed to automate the setup of my development environment.

First on the agenda was to launch Terminal.app and open tabs from a shell script. I found this script which can do that for me:

#!/bin/sh -

# newtab

if [ $# -ne 1 ]; then
    PATHDIR=`pwd`
else
    PATHDIR=$1
fi

/usr/bin/osascript > /dev/null <<-EOF
activate application "Terminal"
tell application "System Events"
    keystroke "t" using {command down}
end tell
tell application "Terminal"
    repeat with win in windows
        try
            if get frontmost of win is true then
                do script "cd $PATHDIR; clear" in (selected tab of win)
            end if
        end try
    end repeat
end tell
EOF

Next up was to be able to launch programs from these tabs. For example, I start PostgreSQL in one tab, and Apache in another.

I used the script above as a basis for this and created termexec:

#!/bin/sh -

/usr/bin/osascript > /dev/null <<-EOF
activate application "Terminal"
tell application "Terminal"
    repeat with win in windows
        try
            if get frontmost of win is true then
                do script "$*" in (selected tab of win)
            end if
        end try
    end repeat
end tell
EOF

And last but not least was to launch Firefox and have it open the webapp automatically:

open $FIREFOX --args $APP_URL

Putting all these pieces together I created a shell script called devapps:

#!/bin/sh -

if [ $# -ne 1 ]; then
    PATHDIR=`pwd`
else
    PATHDIR=$1
fi

# get the directory this script was launched from
bindir=`dirname $0`

# open TextMate
$bindir/termexec "cd $PATHDIR"
$bindir/termexec "mate ."

$bindir/newtab $PATHDIR # for svn, git, etc.

# start Apache
$bindir/newtab $PATHDIR 
$bindir/termexec "httpd -k restart -f $PATHDIR/dev_conf/localhost.conf"

# start PostgreSQL
$bindir/newtab $PATHDIR # for postgres
$bindir/termexec "$PATHDIR/bin/postgresql start"

# open Firefox
open $FIREFOX --args $APP_URL

Next, I created a project specific shell script. In this case demodev:

#!/bin/sh

FIREFOX="/Applications/Johns/Firefox.app"
APP_URL="http://localhost:12001"

export FIREFOX APP_URL

bindir=`dirname $0`

$bindir/devapps "/Users/john/Workspace/demo/jobs"

Almost there, but not quite. I use Alfred App to launch applications. I thought it would be nifty if I could get it to launch my demodev script.

I created a new workflow in Automator and added a Run AppleScript action, and inserted the following AppleScript:

on run {input, parameters}
	
	do shell script "/Users/john/bin/demodev"
	
	return input
end run

I saved this workflow as an Application (in my case I called it Demo Development) and hey presto I was in business. To make sure this runs each time you login, you could add the app to your Login Items. Check out the short video below to see me launching the app from Alfred.

A zero tests, zero edge cases, suck it and see approach to releasing little bits of code.

Of the 10 people (or accounts) returned for me (see below) I am already following 9 of them. I could be wrong, but this seems to counter purpose the app.

I clicked on the follow button to see how that functionality was integrated and I was presented with the authorisation approval screen, which I notice now uses the same ‘Connect’ terminology as Facebook.

I am not a fan of new browser windows that hide the address bar (which happened in Safari 4.0.4, but Firefox 3.6.3 was fine), as it reduces my confidence in the process. But I was so dizzy with curiosity, I threw caution to the wind and clicked the Connect button anyway. My hasty yet not totally irrational action resulted in the following error message:

This is because the callback API supplied is different to the one registered with the Twitter API. The problem stems from the fact that the link in the original blog post contains the ‘www’ subdomain. If you remove that and try again everything works as expected.

Once I authorised Google Follow Finder it recognised the people I was already following. I am still at a loss as to why I am presented with this list though. More confirming than finding is going on.

I wonder has anyone found some sweet new followers with Follow Friend? Why have Google released this I wonder?

While keeping an eye on the Blackburn Rovers versus Manchester United game last weekend, I was annoyed by all the cruft at the top of the page. As you can see in the following screenshots (click for larger size), there is no mention of the current score on either site. The only relevant match information on The Guardian page is what teams are playing.

On desktop browsers the live update pages are automatically refreshed. Unfortunately this is not the case on mobile Safari. It doesn’t take long to get frustrated by this as you have to scroll past it twice (up to top of page, press refresh, back to content) every time you refresh.

After scrolling past the images I could see the updates. As you can see both sites take a slightly different approach here. The BBC site prefixes updates with the time of day, while The Guardian prefixes with the time elapsed in the game. The Guardian also include some rather unhelpful information about refreshing with the F5.

I mocked up what I would like to see on one of these sites. For no particular reason I picked The Guardian for the example.

In the spirit of maximizing the amount of information relevant to the match I decided to eliminate navigation elements (I can use the back functionality of the browser for that), reduce the size of the branding graphic, have the latest score fixed to the top of the screen, and use match time prefixes like The Guardian already use.

In the words of King Kev “I would love it” if The Guardian page was like this.