I have had a 24″ monitor at work for a while and recently bought myself a 24″ for use as a second monitor on my 17″ iMac at home. I really enjoy the extra screen real estate that a large monitor with a resolution of 1920×1200 provides. However most applications don’t really make good use of the massive screen real estate of a large LCD monitor e.g. web browsers viewing fixed width webpages. This leaves you with the problem of how to maximise your usage of your screen real estate, if a single application using the whole display is sub-optimal then viewing two or more applications can be more useful.
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.
I have been playing with Python recently.
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.
Habits and habit forming can be an interesting aspect of human behavior: they seem to fall in to two broad categories in my mind. Habits are either hard to start and maintain until critical mass is achieved and after that can still require conscious maintenance to maintain. Or habits are easy to start but risk becoming all consuming: absorbing more and more time and energy.
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…
Completely off topic but it explains the shameful lack of posts recently:
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 more experienced I become the more aware I become of what I don’t know and the more I come to terms with the fact that I make mistakes.
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.