Sadly this is not the state of computing for most users. The most popular metaphors in computing today – the desktop, the start menu, folders – and commonly learned ways of interacting with them – point and click with the mouse – actually discourage productivity and break concentration/focus from a task. The implementations of these ideas further this interruption. True most users now have been trained to reach for the mouse and their hand eye coordination is good enough to accomplish any given step within a reasonable time frame.

How though does the switch-tasking our brain does to accomplish these steps affect the flow of thought for the current project? Clearly the less divergent thoughts and less steps required for any single step, the less the thought process is diverted from the main task. Further while few people struggle to make the required movements with a mouse, what affect does the repetitive nature of the movement have on long term health and usage? No doubt anyone who uses a mouse on a daily basis for several hours has personally felt the strain on their wrist that naturally comes with such usage.

The modern computing user interface has become cluttered and distracting, albeit a composited, semi-transparent glossy distraction. The initial appeal of such common interface elements hides the distraction, disguises the intrusive elements. It’s as if the computer were telling you, “never mind this modal dialog that just interrupted your thought process, it’s so glossy it must be helpful”.

Consider the average means of launching a program. Is it really ideal to require the user to graphically navigate to some onscreen coordinate that receives instructions before thought is transferred to action? Doubtful. How much screen real estate is essentially wasted for interface elements that support this idea? And how much time is spent arranging or re-arranging the frequently less than ideal placement of windows within this paradigm? Most daily computer users quickly outgrow the nagging tedium of these interfaces, but have no option to adjust the defaults.

I personally prefer an interface that is minimal and stays out of the way. An interface that handles much of what we have come to think of as routine automatically. And one that is fully configurable and flexible enough to support interaction in the manner that works for best me. The tiling window managers available on Linux and specifically Xmonad support this beautifully.

With Xmonad window management is automatic. I do not have to think about window placement as every window is automatically arranged to take the best advantage of screen real estate based on simple rules that I have configured. I can call applications with a single keystroke and they appear exactly where and how I want them. I can send them away or bring them back to the current screen with little more than a gesture, not once having to remove my hands from their comfortable perch above the keyboard. Many applications do not play nicely with this idea though and try to force certain window behavior. For these few troublesome programs it a simple thing to always “float” them, so that they behave in much the same as with traditional window managers. All of it is easily configurable in Haskell, an advanced purely functional programming language that is truly a joy to work with. Because of it concise syntax and clarity, I have been able to easily configure Xmonad to behave as I like, and it’s completely stable.

What is more, the means in which information is communicated is extremely configurable. I chose a minimal status bar using dzen, based on example scripts on the dzen wiki. Information when, where, and how I want it.

I encourage everyone that is using Linux to try it. After just a short period of time, I’m sure you will agree that you are able to work in manner that is both non-intrusive and more productive.

• My Xmonad configuration
• A screenshot of the setup:
• 

• 

  Arch+Xmonad = Crazy Delicious

Haskell

Haskell has been described as the algebra of programming, and is an advanced purely functional programming language. If your a math/language geek like myself, it’s rights up your alley. It’s been a delight to delve deeper into a language I previously had only a passing familiarity with.

Xmonad

Xmonad is a lightweight tiling window manager writen entirely in haskell and it’s rock solid stable because of it. The configuration file itself is a dynamically compiled haskell module, which means your free to do whatever you can within the limits of your knowledge. That’s how it should be. There’s a very fully featured set of community contributed extensions, xmonad-contrib, that provides many more extendable features and the community is helpful and intelligent. Both valuable traits.

Arch Linux

And finally Arch. After a week or two of struggling with Ubuntu/apt and some outdated packages I was so fed up I switch. Rsync’d my entire home directory to my backup server one final time, and did a fresh install of 64 bit Arch. Now least of all its’s nice to have access to all 4GB of RAM in my laptop. Boot times are quicker too.

In all things are snappier, and that make me a happy person.

So I switched. To Arch.

Lately it seems like every useful tip I’ve gleaned has been from either the gentoo or arch wiki, so I had narrowed it down to one of the two. Both are appealing for their BSD style init systems and simple script based pacakge systems. Gentoo is full source though which, while not really a negative for most modern systems, was something I didn’t want to be restricted to. Arch allows a flexible binary or source build system, although the actual repo’s are binary. I love the rolling kernel too, no more waiting 6 months to get the latest, risking a broken system by upgrading in between.

In the process of switching I have fine-tuned things to the extreme. One of the tweaks is the battery status bar I use. It’s just a simple shell script that outputs formatted text to dzen2. It always bugged me that the script didn’t notice the charging state. After a simple little change, it does.

#!/bin/sh
#
# original script by lyon8 <lyon8@gmx.net>
# modifications from original by <sean.escriva@gmail.com>
# show your laptop battery state in dzen
 
BG='#1c2636'  # dzen backgrounad
FG='#99ffff'  # dzen foreground
W=150         # width of the dzen bar
GW=50         # width of the gauge
GFG='#33ccff'  # color of the gauge
GH=7          # height of the gauge
GBG='#333'    # color of gauge background
X=1770        # x position
Y=1200        # y position
FN='snap'     # font
 
STATEFILE='/proc/acpi/battery/BAT0/state' # battery's state file
INFOFILE='/proc/acpi/battery/BAT0/info'   # battery's info file
 
LOWBAT=25        # percentage of battery life marked as low
LOWCOL='#ff4747' # color when battery is low
CHGCOL='#60da11' # color when battery is charging
TIME_INT=1       # time intervall in seconds
 
PREBAR='^i(/home/webframp/.dzen/icons/dzen_bitmaps/battery.xbm) ' # caption (also icons are possible)
 
while true; do
# look up battery's data
BAT_FULL=`cat $INFOFILE|grep design|line|cut -d " " -f 11`;
STATUS=`cat $STATEFILE|grep charging|cut -d " " -f 12`;
RCAP=`cat $STATEFILE|grep remaining|cut -d " " -f 8`;
 
# calculate remaining power
RPERCT=`expr $RCAP \* 100`;
RPERC=`expr $RPERCT / $BAT_FULL`;
 
# draw the bar and pipe everything into dzen
if [ $RPERC -le $LOWBAT ]; then
GFG=$LOWCOL;
fi
if [ $STATUS = 'charging' ]; then
GFG=$CHGCOL;
else
GFG='#33ccff';
fi
#echo -n $PREBAR #uncomment for an icon
eval echo $RPERC | gdbar -h $GH -w $GW -fg $GFG -bg $GBG
sleep $TIME_INT;
done | dzen2 -ta c -tw $W -y $Y -x $X -fg $FG -bg $BG -fn $FN