Consider yourself warned if you are using an RSS reader!

Despite being almost an hour long this is a very insightful video that I’d recommend any Software Engineer watches. I find it fascinating that so many programmers want to erase their perceived (or actual) mistakes in source control systems. I guess everyone secretly wants to be the perfect super programmer. However I typically learn more from my failures than my successes: perhaps it is natural to be more introspective about failure than success?

If you find the title or video too pretentious then the question and answers session (around 42:40) is still quite interesting as the presenters get grilled by the audience.

So here is a brief description of how to do it:

1. Install the X-Code developer tools (for GCC, make and other build tools) from your Snow Leopard installation DvD.
2. Install the X11 Window System from your Snow Leopard installation DvD.
3. Run ‘Software Update‘ from the apple menu on your Mac to get the latest X-Code updates.
4. Download the latest MacPorts installer (.dmg file extension) for Snow Leopard from here: http://distfiles.macports.org/MacPorts/.
5. Mount the installer image file (.dmg) and run the contained MacPorts installer (.pkg).
6. Once installation is complete open a terminal window from Applications->Utilities->Terminal.
7. Type ‘port‘ at the terminal then press enter to run MacPorts.  You should see output like the following if it installed correctly:
   MacPorts 1.8.1
   Entering interactive mode… (“help” for help, “quit” to quit)
   Then type ‘quit‘ then press enter to exit port’s interactive mode.
8. Type ‘sudo port selfupdate‘ and press enter to update MacPorts to the latest version.  You will be asked to enter the administrators password before continuing.  Depending on how new the version you downloaded is, MacPorts may do some upgrading.
9. Once the update is finished type ‘sudo port install py26-matplotlib‘ and press enter.  This will attempt to install the latest version of matplotlib for Python version 2.6.*.   You may be asked to enter the administrators password before continuing.  MacPorts will now download, configure, build and stage the dependencies needed to build the latest matplotlib for Python 2.6.  This took at least thirty minutes on my iMac and involved lots and lots of scrolling text output from the build process.
10. Next we need to switch our environment to use version 2.6.* of Python that MacPorts just built and installed with matplotlib.  To do this run the following two commands, note you may be asked to enter the administrators password before continuing:
    1. ‘sudo port install python_select‘ and hit enter.
    2. ‘sudo python_select python26‘ and hit enter.
11. To test this all worked type the following: ‘python -V’ and hit enter.  You should see output like ‘Python 2.6.4‘ which should match the version of python MacPorts built and installed.
12. Finally to test if matplotlib was installed correctly do the following:
    1. Type ‘python‘ and hit enter to enter the python interactive shell.
    2. Type ‘import matplotlib‘ and hit enter, this will import the matplotlib module.  There should be no output if this works.
    3. Type ‘print matplotlib.__version__‘ and hit enter. This will print the version of matplotlib that is installed, you should see output like ‘0.99.1.1‘.
    4. Type ‘exit()‘ to quit the python interactive shell.

I did this in preparation for getting my act and starting writing again, hopefully new posts should start appearing this week.

This is a very convenient pairing as SQLite is an excellent lightweight SQL implementation that I find very useful for a variety of tasks e.g. data mining.  Or any task involving manipulating complex data sets where I’d otherwise end up resorting to using a full blown SQL server like MySQL.

Here is a simple example of using SQLite in Python using it’s built-in sqlite3 module:

import sqlite3

# craete a connection
con = sqlite3.connect('test.db')

# create a cursor
cur = con.cursor()

# create a test table
cur.execute( "CREATE TABLE testTable (myKey INT, myValue INT)" )

# insert some data
for i in range(0,10):
 cur.execute( "INSERT INTO testTable VALUES ( %d, %d )"%(i,i*i) )

# select the data
for row in cur.execute( "SELECT * FROM testTable" ):
 print row

# destroy (drop) our test table
cur.execute( "DROP TABLE testTable" )

# close the connection
con.close()

As you can see Python makes handling SQLite (a C language library) much easier, less error prone, and the resulting code much more compact than SQLite’s native C.

The simplest solution to this is to manually position and size the windows of your applications so you can view two or more at once.  Arranging application windows manually quickly becomes tedious, due to the many events that can occur in a modern operating system which cause your application windows to be moved around, re-sized or moved to another monitor.

The solution to this problem is using Window Management utilities which allow you to easily re-size and move application windows around, typically using key combinations.  These utilities exist for most operating systems for Mac OS X the window management utility is called SizeUp, the equivalent utility for the PC is called WinSplit Revolution.  I use both of these applications daily, WinSplit is freeware but SizeUp costs a minimum of $4.99 and its worth every cent.  Each utility has some unique features: WinSplit allows you to chain several window configurations on a single key combination and SizeUp allows you to set up a key combination for moving windows between monitors.

I would struggle to maximise my use of one or more large monitors without a Window Management utility.  Hopefully one day this functionality will be built into operating systems as large monitors become more common.  Until then Window Managment utilties are going to be an essential tool that ever serious power user needs.

Here is a little script to change a mac’s desktop wallpaper to the file specified as the first argument of the script:

import subprocess,sys,os

# Raw apple script
Script = """/usr/bin/osascript<<END
tell application "Finder"
set desktop picture to POSIX file "%s"
end tell
END"""

# get the file name which is the first argument passed to this script
filename = sys.argv[1] 

# run the apple script inserting the filename
subprocess.Popen(Script%filename,shell=True)

Or using the nifty appscript module for python:

import sys
from appscript import app, mactypes

# get the file name which is the first argument passed to this script
fileName = sys.argv[1]

# use the appscript module to change the desktop wallpaper
app('Finder').desktop_picture.set(mactypes.File(fileName))

The more I use Python the more I like it.  I used to think Python was at a similar level to C# in terms of how high a level a programming language it is.  After using Python for a bit I now realise that Python is a higher level programming language than C#.  Out of the languages I use reguarally it would seem that Python is the highest level language followed by C# then C++ and finally C.

An example of a hard to start habit for me is writing blog posts: it took a force of will to start me writing initially and it requires constant energy to keep me writing new posts.  Interruptions over even a week to my writing can be enough to disrupt my writing habit sufficiently to halt it.  At which point Inertia comes into play with devastating effect, to make the restarting of the habit hard.  It seems that a lot of virtuous habits like regular exercise and eating healthily also fall into this category.

A habit that is easy to start and yet easily becomes all consuming for me is playing computer games, usually this doesn’t get too out of hand as most games have a finite length and amount of content which limits the duration of the disruption.  Yet some games, especially MMOs like World of Warcraft (WoW) have a seemingly endless stream of content which means that it is possible to spend an almost infinite amount of time playing the game and still not complete it.

These ‘time sink’ games can be a real challenge to getting anything else done, my usual solution to this situation is to stop playing the game by unsubscribing…

I finally got my Orc Shaman ‘Urki‘ in World of Warcraft to level eighty!  I only started levelling him in January so I’ve been pretty slow (restrained) but now I can finally start playing in the arena (PvP).

I also managed to get the artisan riding skill so I can use epic flying mounts.  Having an epic speed flying mount (this is my current) makes a huge difference to travel times, which I hadn’t fully appreciated before.

The awareness of what I don’t know helps keep me humble, humility makes working as part of a team easier:  as there is no pressure to have to know everything or not make mistakes.  In fact I tend to expect to make mistakes more now than when I first started programming.  Perhaps it is the years I have spent shipping games that finally proved to me that I too write software that contains bugs (the horror!).

I remember a professor at university telling me that the main difference between a professor and a first year student working on a programming task is that the student will start working immediately and also start making mistakes immediately, the professor will think for a while then start work and start making mistakes as well.  I have found this observation to have a surprising amount of truth in it,:whether it is at university, work or even sports.

Mistakes are healthy: without mistakes we would have not reason to every really think about what we are doing e.g. why didn’t that work?  By continually pushing (or stretching) ourselves to failure we discover our boundaries, once we know where are our boundaries are we can then start to work on pushing them further.  However if we always play it safe and never push ourselves (which can be scary) we will never discover our boundaries which makes improvement much harder and also makes approaching those boundaries harder due to fear (typically of loss of control).

An excellent example of this is people learning to ice skate: young children will tend to fling themselves around the rink with wild abandon falling all over the place (as failure is expected but irrelevant due to lack of social stigma), yet adult beginners typically skate in a much more conservative fashion taking less risks (as there is social stigma against falling as an adult: falling is seen as failure).  Interestingly when observing ice hockey players, it is noticeable that those with the best skating technique are typically falling more than the other the non-beginner players on the ice, as they do not fear falling.

As most of us are not engaged in high risk activities on a daily basis we can easily begin to revise how we think about failure and to learn to embrace it as a powerful tool for self improvement.