Since mutt is my favorite email client, I manage to configure it to let me use multiple identities at need. This means that my configuration must take care of setting the correct sender address (the From: header) and the correct signature whenever I need to compose a new message or reply to one I received.

Setting the sender address

There are few changes you have to do to let mutt configure the sender address correctly. First ensure that you have the $alternates set in your .mutt.rc configuration file:

alternates = "(you@domain.tld)|(you@otherdomain.tld)"

then set the following variables:

# Allow editing of headers when composing a message
#
set edit_headers

# Set the From: header to the original's To: when
# replying to a message
#
set reverse_name

# Use the $from variable for the sender address
#
set use_from

This configuration takes care of setting the correct sender address when replying to a message. Now you only need to teach mutt how to choose different identities when composing a new email. The trick is done by these two macros:

macro generic "<esc>1" ":set from='You <you@domain.tld>'"
macro generic "<esc>2" ":set from='You <you@otherdomain.tld>'"

Simply press <esc>1 and then m to compose a new email using the first address, or press <esc>2 and then m to use the second one.

Setting the signature

To set the correct signature, send-hooks are needed. Add the following lines to your configuration:

send-hook "~f you@domain.tld" "set signature="~/.domain.sig""
send-hook "~f you@otherdomain.tld" "set signature="~/.otherdomain.sig""

Mutt decides which signature to use by looking at the sender address of the message.

A: using my mail reader as a feed aggregator.

Over time I tried many different RSS feeds aggragators, both web based and stand alone applications. There are many which are really nice, but every one I tried was lacking one feature or another. I saw that the Thunderbird mail reader has the option to handle RSS news as emails, so I decided to look for something that enabled me to the same with mutt, my mail reader of choice.

I found a really nice tool called feed2imap, which perfectly addresses my needs. It is really easy to setup and configure - the configuration file is well commented - and does it's job smoothly. Now I have all my news in dedicated mailboxes.

I am a great fan of tiled window managers, and been a long time user of dwm. I also love to work with my keyboard most of the time, and except for graphic and web surfing, I hardly need a pointing device (I use a trackball, by the way).

What I was looking for was a tiled window manager with a more flexible approach to layouts, and some kind of keyboard driven web browsing interface with the same rendering capabilities that firefox provides. For the window manager I gave awesome a try, and after some configuration I am pretty satisfied with it. For the web browsing interface I decided to install the vimperator firefox extension; it seems to be very powerful once you get used to key mappings (which in the end are the same that vim uses).

I'm going to post more impressions on both tools as soon as possible.

gs -dNOPAUSE -sDEVICE=pdfwrite -sOUTPUTFILE=Document.pdf -dBATCH \
     1.pdf 2.pdf 3.pdf

Next time I'm going to need it, I won't have to do the usual Google search.

Basically, watch does what the curses mode of lsmbox did: run a command every n seconds. So i just added the following alias in my .bashrc file:

alias mymail='watch -t -n 300 lsmbox -n -s -S -t /home/adotti/Mail/'

and I got the handy list of mailboxes with unread messages back.

Having some unexpected spare time, I decided to write a little helper to save me some key strokes. I don't know if it can be useful for anyone but me, by the way, you can download it here.

Few days ago I had the occasion to get a quite old but really robust keyboard. I guess it's from the 90's, but it still have a really wonderful touch and works very very well.

Since it has an Italian layout, I took some time to configure dwm for switching between American and Italian layouts.

I just added the following lines to the config.h file:

        { MODKEY|ShiftMask|ControlMask, XK_i, spawn, "exec setxkbmap it" }, \
        { MODKEY|ShiftMask|ControlMask, XK_u, spawn, "exec setxkbmap us" }, \

and recompilied dwm. It works flawlessly.

Some days ago I had the need to rip a cd to load the tracks on my portable player. It seems that the version of cdparanoia included in etch (currently 3.10+debian~pre0-4) is broken and unable to rip anything. The only working solution was to downgrade the package to the version included in sarge.

After the switch, I needed to find a way to be notified of incoming messages; something simple, like a visual indicator or the like. mcabber can handle incoming events and execute an external script, so the only thing to do was finding a suitable tool for notification. Browsing around I found dzen, a general purpose notification utility. It is like a post-it you can put anywhere on the screen and it is very flexible.

So this is how I put things together:

$ vi .mcabber/jabber.org-rc

[...]
set events_command = /home/adotti/bin/notify.sh
[...]

and this is the notification script:

#! /bin/sh
#
# Simple event notifier for mcabber. Uses dzen2 to display messages.

event=$1
msg=$2

if [ $event = "MSG" ]; then
        case "$msg" in
        IN)
        ;;
        MUC)
        ;;
        OUT)
                exit 0
        ;;
        esac
        killall dzen2 > /dev/null 2>&1
        (echo "IM") | \
        dzen2 -p -x 1100 -w 30 -fn "-artwiz-snap-*-*-*-*-10-100-75-75-p-*-iso8859-1" &
fi

Note that I kept things really simple and there is a huge room for improvements. Anyway, every time an incoming message arrives, a little red square appears near the top right corner of the screen.

Dirò una cosa ovvia, ma se si vuole utilizzare sempre l'ultimissima versione di un'applicazione, è caldamente consigliato aggiornare senza saltare versioni in mezzo. Questo, ovviamente, in un mondo perfetto dove la disponibilità di tempo è praticamente totale. Nella realtà, il tempo non sempre c'è, e gli upgrade non sono sempre indolori; il dolore provato dipende dalla complessità dell'applicazione che si usa.

Nel mio caso, mi sono trovato ad aggiornare dwm dalla versione 3.3 alla neonata 3.7... e nel frattempo il codice dell'applicazione è stato ampiamente ripulito, lasciandomi con un file di configurazione praticamente inutilizzabile. Considerate che il mio C è particolarmente arrugginito, quindi la gestione dei pittoreschi errori che mi sono presentati in fase di compilazione non è stata proprio banale.

In trenta minuti di sevizie alla tastiera mi sono guadagnato un posto privilegiato in uno dei gironi danteschi, ma almeno il mio window manager preferito viaggia liscio come l'olio, e, a quanto mi pare di percepire, più veloce di prima.

Morale della favola: il feticismo può anche essere doloroso, e la macchie di sangue sulla tastiera potrebbero finire per essere le tue. Talvolta ne vale la pena.

Aggiungendo questa riga nel vostro .xsession (o .xinitrc, a seconda di quello che usate):

echo "[`xwininfo -root -children 2>/dev/null \
| grep Psi \
| grep -c '*'`]"

vi comparirà nella status bar il numero di finestre di psi che hanno cambiato stato - ovvero che contengono nuovi messaggi o altre notifiche.

Una piccola avvertenza: la gestione del fuoco delle finestre attraverso i diversi tag, in dwm, non è propriamente intuitiva, per cui, per avere una informazione corretta, dovrete adattarvi un attimo.

Per i curiosi, ecco il mio .xsession completo.

export PATH=$PATH:/home/adotti/bin
while true
do
    echo "[`xwininfo -root -children 2>/dev/null | grep Psi | grep -c '*'`]" \
    `date "+%Y-%m-%d [%R]"` \
    `uptime | cut -c 14-18`
    sleep 2
done | dwm

Un grazie ad Antoni Grzymala per i suggerimenti.

fatto da Enrico a Brixen.

Provando a caso un po' di filtri ed effetti vari, abbiamo individuato questa combinazione di passi:

• applicato il filtro retinex
• sperimentato con il filter pack per dare un po' di colore
• applicato in primo piano un layer nero semi trasparente

Il risultato è questo:

Usato come sfondo ha veramente qualcosa da dire.

Se volete, potete scaricare l'immagine a grandezza naturale (1280x1024).

Di default ikiwiki non copia tutto ciò che ha estensione html o xhtml (più diversi altri tipi di file che è sano ed inutile copiare). Questa è una precisa scelta - dettata da ragioni di sicurezza - ma, nel caso, è possibile configurare le cose affinchè il comportamento sia diverso.

Esiste la variabile wiki_file_prune_regexps che si occupa proprio di questo, istruire ikiwiki sul tipo di pagine da ignorare. Il valore di default - scritto direttamente nel codice - è il seguente:

wiki_file_prune_regexps => [qr/\.\./, qr/^\./, qr/\/\./, qr/\.x?html?$/,
            qr/(^|\/).svn\//, qr/.arch-ids\//, qr/{arch}\//],

Questa variabile può essere aggiunta al file di configurazione di ikiwiki e modificata secondo necessità, includendo ed escludendo ciò che più vi aggrada. Il nuovo valore sovrascriverà il default.

Notate che la cosa non mi sembra documentata, per cui potrebbero esserci modi più intelligenti di agire. Questo di certo funziona.

Purtroppo la gestione keyboard driven è leggermente meno intuitiva di quella basata su mouse, per cui ho riscontrato tutta una serie di comportamenti buffi a cui non ero preparato (specie nella gestione del focus dei vari oggetti).

Altra cosa che mi ha spiazzato non poco sono state le difficoltà in fase di debugging. Per come viene gestito l'output, il debugger perl è praticamente inservibile. Per fortuna è possibile ridirigere lo standard error su un file e, attivando l'opzione di debug della libreria, si riesce a creare un file di trace tutto sommato utile.

Al di la di questi piccoli inconvenienti, sicuramente superabili con una lettura più approfondita della documentazione ed una maggior pratica nell'utilizzo, Curses::UI mi sembra un buono strumento per realizzare qualcosa che consenta un minimo di interazione con l'utente. Magari non adattissimo per cose particolarmente complesse, ma comodo da avere a portata di mano.

Delle patch contribuite dai diversi partecipanti alla mailing list del progetto è stata fatta una raccolta pubblicata sul sito ufficiale. Di mio, ve ne segnalo una che trovo molto utile:

bottom stack patch

Consente di modificare l'orientamento delle colonne in cui viene diviso lo schermo da verticale ad orizzontale. Una manna se dovete analizzare dei log o modificare dei file con righe molto lunghe e non volete ricorrere a finestre massimizzate.

Basta patchare i sorgenti, modificare il file di configurazione e ricompilare... come al solito :)

Se siete interessati a dare un'occhiata approfondita al formato utilizzato dalle vCard potete fare riferimento alla RFC2426, che ne descrive in modo esaustivo tutti gli aspetti.

Ho passato un paio di giorni fa un'oretta a giocare un po' con alcune delle vCard che, nel tempo, mi sono state inviate per posta elettronica da amici e corrispondenti vari. In particolare, ero interessate a costruire un qualcosa che mi permettesse di visualizzare una card in modo più agevole rispetto al formato nativo (testuale e comunque leggibile).

Avendo voglia di scrivere un po' di codice perl, ho utilizzato il modulo Text::vCard - facilmente reperibile su CPAN. La libreria in questione è ben fatta e, per quanto non ancora completa, molto semplice da usare. Non è ancora possibile gestire le informazioni di tipo binario (foto, sample sonori etc.), e l'export nel formato vCard non gestisce (ancora) correttamente l'escape dei caratteri, ma se il vostro obiettivo è la sola visualizzazione, questo modulo semplifica di molto il lavoro.

Se avete voglia di vedere un po' di codice reale, scaricate vcfreader.pl e giocateci liberamente. Penso che possa essere un buon punto di partenza.

Recentemente ho cercato di migliorare la mia gestione dell'uso di gpg per firmare le e-mail quando ne ho necessità. Non ne faccio un sistematico, ma ci sono diverse situazioni in cui mi è utile apporre la mia firma digitale ai messaggi in uscita.

La versatilità di Mutt offre un discreta quantità di parametri di configurazione, e bisogna dire che i default impostati sono saggi e consentono un'uso di gpg praticamente immediato. Ho comunque limato qualche piccolo spigolo. Questo è il pezzo di configurazione personalizzato che ho aggiunto al mio muttrc:

# non firmare automaticamente tutti i messaggi in uscita
#
unset crypt_autosign

# non cifrare automaticamente tutti i messaggi in uscita
#
unset crypt_autoencrypt

# cifra automaticamente le risposte a messaggi cifrati
#
set crypt_replyencrypt

# firma automaticamente le risposte a messaggi firmati
#
set crypt_replysign

La versione 1.5 è appena stata rilasciata, e contiene una feature aggiuntiva che personalmente trovo molto comoda. E' possibile allargare/restringere la dimensione della master column al volo; gli incrementi sono configurabili, al solito, nel file config.h. Niente più compilazioni supplementari nel caso vi accorgeste che per fare una particolare operazione avete bisogno di finestre tiled più grandi.

Altra funzionalità aggiunta, che però io non uso, è quella di visualizzare contemporaneamente tutti i client associati a tutti i tag.

Il file di configurazione differisce di sole tre righe dalle versioni precedenti (almeno dalla versione 1.2, da cui ho fatto l'aggiornamento), per cui l'upgrade è più veloce del solito.

Infine, una cosa che non ho potuto verificare, ma che è stata riportata nella mailing list degli sviluppatori, è che dwm gira anche sotto MacOSX. Se l'interfaccia standard di casa Apple vi sembra troppo carica...

Buona compilazione.

Indagando un po', mi sono reso conto che il problema era originato dalla presenza dei lettere accentate italiane; andavano rimosse e sostituite con le relative codifiche html.

Ho buttato giù due righe in perl per automatizzare il lavoro:

#!/usr/bin/perl
#
# Replace italian accents with html alternates

open STDIN, '-';

while (<STDIN>) {
        s/&agrave;/\&agrave\;/g;
        s/&egrave;/\&egrave\;/g;
        s/&igrave;/\&igrave\;/g;
        s/&ograve;/\&ograve\;/g;
        s/&ugrave;/\&ugrave\;/g;
        print;
}

Notate che non sono presenti accenti acuti... so di essere un barbaro ma per semplicità non li uso.

Con il seguente comando:

for i in *.mdwn; do cat $i | htmlize.pl > $1; done

sono riuscito a sistemare il contenuto dei file in meno di un minuto (htmlize.pl è il nome che ho dato allo script di cui sopra).

Per chi invece avesse necessità di fare conversioni da diverse codifiche in utf-8 - ma non solo - suggerisco l'utility tcs. Semplice quanto comoda... (attenzione che non supporta la codifica iso-8859-15; ovvero niente simbolo dell'euro).

Mentre la cosa non ha praticamente impatto quando devo gestire compiti lunghi o complessi, ogni volta che mi trovo a gestire cose che si fanno in meno di cinque minuti la cosa più frequente che finisco per fare è rimandarle. Evidentemente la mia capacità di concentrazione nel brevissimo periodo fa schifo.

Per cercare di ovviare a questa situazione, e per cercare di riportare le mie todo list ad una lunghezza umana, ho deciso di dotarmi di un timer. Impostare slot temporali definiti sta dando ottimi risultati.

Ho cercato abbastanza a lungo un software che fosse semplice e fosse adeguato alle mie esigenze. osdclock è apparso la scelta migliore. Si tratta di un orologio che si piazza in uno degli angoli del desktop e rimane sempre in primo piano. Inoltre ha la simpatica funzione di accettare un ritardo prima di visualizzarsi. Posso lavorare tranquillo e senza distrazioni su di una cosa fino al momento in cui l'ora mi compare, in caratteri cubitali rossi, nell'angolo inferiore destro del mio monitor.

Ho costruito anche un piccolo wrapper che mi consente di lanciare osdclock con tutte le opzioni necessarie, specificando anche il ritardo che desidero.

Eccolo qui:

#!/bin/bash
if [ "$#" != '1' ]
then
        echo "usage: $0 <delay>"
        exit 1;
fi
TIME=$1
/usr/bin/killall osd_clock
/usr/bin/osd_clock -s 0 -f -*-courier-bold-r-normal-*-18-180-75-75-*-110-iso8859-1 -r -w $TIME &
exit 0;

Nota bene: se non usate Linux ma altre varianti di Unix, potreste dover sostituire killall con il comando equivalente appropriato per il vostro sistema.

Questa nuova uscita presenta una succosa novità, ovvero la possibilità di fare merge di più tag, in modo raggruppare nella vista corrente tutti i client appartenenti ai tag coinvolti nell'operazione. Un pizzico di flessibilità abbastanza utile, specie se siete un po' disordinati nel disporre le cose (o se cambiate spesso idea).

Segnalo anche l'eliminazione della navigazione sequenziale fra i tag, oltre al cambiamento di qualche keybinding nella configurazione di default. Considerando che dovrete mettere mano al file di configurazione prima di compilare il tutto, la cosa non dovrebbe essere un problema: potete facilmente ripristinare la cose secondo gusto.

Buon upgrade.

La nuova release è appena uscita, e dovremmo ormai esserci per avere una versione che includa tutte le feature previste e sia stabile nella configurazione; le note per l'aggiornamento segnalano infatti alcune modifiche non appariscenti e alcuni bugfix, oltre ad un (ennesimo) cambiamento nel formato del file di configurazione (più compatto e, purtroppo, un po' più complicato).

Intanto, parallelamente allo sviluppo di dwm, prosegue anche lo sviluppo di dmenu, applicazione concepita come gestore di menu autonomo che può essere usato con qualsiasi window manager. Ricorda molto il menù di wmii.

Sempre dal fronte del programmare entro le diecimila linee di codice, pare sia in lavorazione un emulatore di terminale... aspettiamoci un'altra mirabolante creatura minimale con cui divertirci questo autunno.

Trattandosi di un window manager minimale, il numero delle feature aggiunte tende a zero; sono state sistemate alcune cosette e, per facilitare l'approccio elitario alla configurazione, tutte le opzioni sono state raggruppate nel file config.h. Niente più editing dei file .c sparsi nell'albero dei sorgenti :) Un'altra cosa che ho apprezzato è la possibilità di spostamento sequenziale tra i workspace usando i tasti h e l. Fa molto vim e fa pure molto confortevole.

Un gioco breve, in ultima analisi, ma certo soddisfacente.

Dei progetti ospitati, ho provato i due window manager, wmii e dwm

wmii

Sono da tempo un fan di window manager che abbiano una filosofia diversa rispetto ai soliti ambienti a finestre. Inoltre ho sempre cercato, per quanto possibile, di individuare quelli che, oltre ad essere leggeri, fossero anche comodi da gestire tramite tastiera.

wmii (che uso con soddisfazione da diversi mesi) ha alcune feature molto interesanti, oltre alle sopracitate caratteristiche. In primis, cerca di utilizzare i workspace in modo diverso dal solito; ai vari client (le applicazioni) possono essere applicati un numero arbitrario di tag, il che consente di raggrupparli in modo dinamico a seconda di cosa si stia facendo. Le finestre, inoltre, vengono gestite automaticamente in modo da occupare la maggior superficie disponibile sullo schermo (tiled mode), per quanto sia possibile attivare il consueto floating mode se le applicazioni che si stanno usando lo richiedono.

Altro punto a favore di wmii è quello di avere una configurazione abbastanza semplice, costituita da un unico shell script che viene eseguito in automatico all'avvio oppure manualmente ogni volta che serve riconfigurare al volo il window manager. Facile quindi intuirne la flessibilità e altrettanto facile intuire che la configurazione può non essere banale quado si portano le personalizzazioni all'estremo.

L'intero ambiente di lavoro può anche essere controllato dinamicamente modificando i valori presenti nel filesystem virtuale (stile /proc per intenderci) che il window manager esporta.

Per contro, il look è abbastanza spartano e la gestione delle applicazioni che usano molte finestre non massimizzate (come Gimp) è sicuramente perfettibile.

dwm

dwm (Dynamic Window Manager) è un altro window manager molto interessante, per quanto al momento ancora un po' immaturo (siamo alla versione 0.5).

Cito dal sito:

Because dwm is customized through editing its source code, it's pointless to make binary packages of it. This keeps its userbase small and elitist. No novices asking stupid questions.

Questo vi fa capire cosa avrete per le mani, se vorrete provarlo. Tutte le personalizzazioni si fanno modificando il file dwm.h, ed altri file sorgente (tag.c, event.c, main.c) presenti nell'albero del codice, prima della compilazione.

La filosofia è un'estremizzazione di quella di wmii (da cui dwm evidentemente deriva) e l'ambiente di lavoro nudo e crudo. Interessante, oltre alla gestione dinamica dei tag, anche la gestione dinamica delle finestre; si può passare dalla modalità tiled alla modalità floating al volo, cosa molto utile..

Qualche tempo fa ho letto il libro di David Allen "Getting Things Done" e ne ho tratto diversi spunti interessanti. In particolare, la gestione delle cose senza priorità e il raggruppamento delle attività in liste a tema.

Gli strumenti

Per mettere in pratica alcuni dei consigli elencato nel libro di cui sopra, il primo passo è stato quello di individuare degli strumenti consoni alle mie necessità ed al mio modo di operare. Se fate una breve ricerca in rete, troverete tonnellate di sistemi preconfezionati che si ispirano più o meno fedelmente a GTD... L'utilizzo di uno strumento omni comprensivo è una possibilità molto accattivante (avevo inizialmente pensato di adattarne qualcuno o di scriverne uno ex-novo), tuttavia ho preferito orientarmi verso qualcosa che non mi vincolasse ad una piattaforma particolare, o meglio, ad un computer particolare.

Cosa meglio di un editor di testo?

Il formato testo ha il vantaggio di poter essere modificato ovunque, anche da remoto, ed ogni sistema che ho utilizzato ha almeno un editor di testo incluso nell'installazione standard (mi rendo conto che ciò che ho appena detto può sembrare ovvio, ma siccome incontro ancora persone che credono che i file in formato Microsoft Word siano uno standard...).

Convenzioni

Le cose da fare sono raggruppate in file; un file per progetto o per contesto (ad esempio, nel file sourceforge.otl ho raccolto tutto quello che devo fare quando sono collegato ai server di sourceforge.net). Non sono abituato a ragionare in modo troppo schematico, quindi avere le cose organizzate in questo modo mi torna molto utile.

I singoli file sono di fatto degli outline, con le azioni disposte in modo gerarchico per poter individuare facilmente l'ordine delle attività e le loro dipendenze. Suggerisco a cui utilizza Vim come editor di testo il plugin TVO; è molto comodo.

Non utilizzo priorità in modo diffuso, tuttavia mi torna molto comodo evidenziare le cose da fare urgentemente e quelle che, per un qualche motivo, sono in sospeso. Uso i seguenti tag da premettere all'azione:

• (U): cosa urgente
• (H): cosa in sospeso
• | : commento/nota

ovviamente l'elenco si può estendere e personalizzare a piacimento.

Gestire le azioni

Uno dei suggerimenti del libro di David Allen è quello di prendere la prima azione di ciascun progetto e farla, oppure processare le azioni di un particolare contesto una dopo l'altra finchè se ne ha la possibilità. Non amo questo approccio... lo trovo un po' dispersivo. Preferisco scegliere un progetto e lavorarci sopra finchè ne ho voglia (o necessità).

Utilizzare dei file di testo strutturati come outline, e delle etichette da abbinare alle azioni quando si desidera, rende molto facile automatizzare il processo di gestione ed adattarlo alle proprie necessità.

Questo frammento di codice permette di elencare il numero di azioni per ogni file:

for file in ~/gtd/*.otl;
do
    printf "%-20s: %3d\n" $(basename $file .otl)
        $(cat $file | perl -ne "next if /^\W*(\|)/; print" | wc -l);
done

(è stato indentato per chiarezza ma va scritto tutto su una riga. Funziona con la shell bash di Unix).

Se conoscente almeno un po' un qualsiasi linguaggio di programmazione estendere quanto sopra è facilissimo. E gestire le vostre cose da fare molto più rilassante.