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

One of the first things I like to do is blacklist pcspkr, I hate that beep and it is almost always useless for me. It seems the kernel module name has changed from pcspkr to snd_pcsp, had to change the line accordingly /etc/modprobe.d/blacklist

Wireless also doesn’t work, but the drivers have changed from what I understand, so that’s to be expected.

It should be fun to explore the rest if the Intrepid Ibex and see what’s new.

;t

It highlights all available links in the current page and assigns them a number. Type the number to have the link launched in a new tab in the background. Less time wasted mousing around on the page, awesome.

Just untar (tar xzvf romanian-fortunefiles.tar.gz) wherever you like and use it.
Any romanian linux users please feal free to correct my mistakes, although I tried to do the best I know. It would be great to add more as well, as long as they’re clean.

In the process of switching I’ve been reviewing many a startup file and rc file, tweaking things to be just right. Every detail is important when using a minimalistic window manager. Lot’s of things have been useful, urlview combined with this handy script, the firefox vimperator plugin and my .vimrc and .zshrc. Out of everything one of the easiest overlooked, and yet most helpful, is setting a sensible environment.

Three variables are used by a wide variety of programs to display or edit your data, PAGER, EDITOR and BROWSER. Choices here are obviously a matter a preference, but these are the settings I’ve found to be most useful.


{a,ba,da,k,z}sh syntax:

PAGER="less -MS"
EDITOR="vim"
BROWSER="/usr/bin/firefox"
export PAGER EDITOR BROWSER

or

{t}csh syntax:

setenv PAGER "less -MS"
setenv EDITOR vim
setenv BROWSER /usr/bin/firefox


all pretty standard stuff, goes in your shell initialization file or /etc/environment to make it global. Substitute emacs for vim if you want, and more for less. less seems to be faster for larger files which is why I use it. the -MS options for less provide extra features. -M provides browsing information about the current file and -S disables line wrapping. -N is also useful occasionally to display line numbers for a file, maybe not for every file, which is why I leave it out. My exploration continues, so that’s really it for now but on a side note: If anyone out there can get ruby-wmii to control mpd drop me a line, I couldn’t seem to get it working among other things. Of course some python bindings to do the same would work equally well.

Now I’m not going to manually edit each file on each machine to have some fancy individual ascii art hostname. I don’t have time and that’s not the point, especially when there’s plenty of utilities that will do it for me.  These should all be available in your distros repositories as they’ve been around for some time.

Figlet:

The best one for this job is FIGlet, but then again, that depends on your preference. From the home page: “FIGlet is a program for making large letters out of ordinary text”. So a simple command like:

figlet -f smslant -S megatron | sudo tee -a /etc/motd

Will append this to your /etc/motd

                       __
  __ _  ___ ___ ____ _/ /________  ___
 /  ' \/ -_) _ `/ _ `/ __/ __/ _ \/ _ \
/_/_/_/\__/\_, /\_,_/\__/_/  \___/_//_/
          /___/

Nice and easy. -f decides what font to use. Typically on most *nix-en these will be in /usr/share/figlet/, but the basics are: banner, big,  block, bubble, digital, ivrit, lean, mini, mnemonic, script, shadow, slant, small, smscript, smshadow, smslant, standard and term but there are others. There are lots of other options for FIGlet,  so read the man page.

Boxes:

Boxes is  a utility designed to be called from within your editor and works really well to comment out blocks of code.  It can also be used to generate some basic ascii banners suitable for use in your /etc/motd

webframp@megatron$ boxes -d nuke -a hcvc
megatron
^D

        _ ._  _ , _ ._
      (_ ' ( `  )_  .__)
    ( (  (    )   `)  ) _)
   (__ (_   (_ . _) _) ,__)
       `~~`\ ' . /`~~`
       ,::: ;   ; :::,
      ':::::::::::::::'
 _jgs______/_ __ \__________
|                           |
|         megatron          |
|___________________________|

Tada, a nice little mushroom cloud for your login message. ^D represents your EOL character, typically Control-D, but you knew that. Again see the man page for more options.

Cowsay/Cowthink:

Cowsay/cowthink is a configurable speaking/thinking cow. It can be used to make your message appear to come from a cow:

webframp@megatron$ cowsay
megatron!
^D

 ___________
< megatron! >
 -----------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

And the hillarity ensues. Cowthink will make it a thought bubble instead of a speech bubble. Cowsay can also be combined with boxes or figlet to make your cow say or think the output of those commands. More info is in the man page.

Do you use something else? Whats your preferred /etc/motd format?

Most likely I will since I don’t have the patience to wait.