Il 23 maggio ho avuto il piacere di presentare il mio primo talk nel primo appuntamento del Florence On Ruby!

E' stata un'ottima esperienza, che sicuramente bisserò il prima possibile. CoffeeScript è un linguaggio che continua a venire visto con diffidenza e per mostrarne l'utilità si è costretti a portare esempi concreti, con del JavaScript mediamente avanzato (closure wrappers e function binding, per esempio).

Sembra che i vari concetti siano stati assorbiti piuttosto bene, cosa che mi rende felice. Condivido qui slide e il talk stesso (la qualità è quella che è, ma il parlato mi sembra abbastanza comprensibile).

Quando si tratta di gestire una piccola compagnia di sviluppo software, essere in grado di stimare i tempi di consegna dei progetti in corso, e dunque poter pianificare le disponibilità future dei (pochi) sviluppatori è fondamentale.

Uno degli strumenti più semplici ed efficaci in grado di fornirci delle metriche tali da farci arrivare a quest'obiettivo è proprio il time-tracking.

Il problema: time-trackare fa schifo

Sei uno sviluppatore? Bene, allora sai quanto sia intimamente disturbante e innaturale l'atto del time-tracking, soprattutto se imposto dall'alto. Nonostante riconosca il suo valore nel medio periodo, non c'è cosa più odiosa e facile da dimenticare.

Quando farlo? A fine giornata? Ci sono giornate così lunghe che ricordarsi con un minimo di dettaglio cosa e quanto è stato fatto la mattina è semplicemente impossibile. Ad ogni context switch? Figuriamoci.. non è raro dover alternare task ogni 5-10 minuti.. e se ogni volta si dovesse segnare il tempo..

Bisogna fare qualcosa!

Pomodoro

Una tecnica molto semplice e che consiglio a tutti per aumentare la propria capacità di concentrazione — e dunque ridurre i context-switch — è quella del Pomodoro:

• Scegli un task da completare;
• Imposta il Pomodoro a 25 minuti (il Pomodoro è il timer);
• Lavora sul task senza distrazioni o interruzioni fino a che il Pomodoro non suona;
• Prenditi un piccolo break (5 minuti vanno bene);
• Ogni 4 pomodori prenditi una pausa un po' più lunga.

Nonostante la banalità (o proprio grazie a questa) posso garantire che funziona, e rende drammaticamente visibile fin da subito la quantità di cambi di contesto che mediamente eseguiamo senza rendercene conto.

Ogni 25 minuti il rumore di un timer da cucina parte a festeggiare il periodo di concentrazione appena concluso, ed il ticchettio continuo dopo poco tempo verrà associato a sentimenti positivi e di "buon lavoro".

Come avrete intuito, il Pomodoro è involontariamente un'ottima forma di time-tracking: non viene percepito dallo sviluppatore come una inutile imposizione dall'alto, ma come strumento di supporto attivo al proprio lavoro: da quando lo utilizzo, le mie ostilità verso il concetto di time-tracking sono pressochè terminate.

Redpomo

Dopo l'illuminazione di qualche mese fa col Pomodoro, il mio workflow nell'ultimo mese si è ulteriormente raffinato. Il risultato finale è Redpomo, una gemma che integra e amalgama insieme i 3 strumenti che utilizzo giornalmente.

Qui in fondo uno screencast per spiegarvi meglio di cosa si tratta.

In effetti mi sembrava che fosse tutto troppo tranquillo ultimamente. Qualcosa doveva capitare. Sta capitando.

Innanzitutto, nuova sfida lavorativa! Era da qualche tempo che seguivo le mosse di Cantiere Creativo, una delle principali realtà Ruby a Firenze, ed il caso ha voluto che fosse proprio Matteo a contattarmi per una proposta allettante: tentare di sostituire degnamente Silvio, in procinto di iniziare la sua avventura con Extendi.

In Cantiere ho ritrovato molti dei punti fermi che stiamo cercando di perseguire in weLaika: passione per la trasparenza, impegno nel mondo open source, voglia di fare community, ricerca di qualità.

Ho pensato che un po' di sana compagnia nel mio lavoro quotidiano da remote worker per weLaika non poteva che fare bene, così come il mettere il piede in una società per certi versi molto simile a quella che desideriamo costruire, ma con maggiore esperienza e contatti.

Per qualche mese tenterò quindi l'esperimento di far convivere il mio costante impegno in weLaika, con questa nuova posizione di responsabilità in Cantiere, continuando lo sforzo di Silvio nello sviluppo del CMS open Rails-based Railsyard.

Se latito, ora sapete il perchè.

Appuntamenti per coders!

A Marzo, con la bella stagione, parte il primo gruppone di eventi per nerd. Prima di tutto, il CodeMotion di Roma, il 23 e 24 marzo. Ci sarete, vero?

In weLaika, in forte astinenza del RailsRumble che sembra latitare, ci auto-organizzeremo in 48 ore di forsennato coding in compagnia, se qualcuno in Torino volesse unirsi sarà il benvenuto!

In Cantiere si sta cercando di organizzare verso fine mese il primo Ruby Social Club fiorentino, anche se è probabile che non si chiami proprio così. Non c'è ancora una data precisa, ma appena si saprà qualcosa di preciso batterò un colpo su Twitter.

A couple of weeks ago Josh Davey released turbux, a great vim plugin that aims to keep your TDD feedback loop faster and less prone to unnecessary context-switches through the use of split sessions and tmux.

Before you continue reading this post, check out the announcement post on his blog, so you know what we're talking about.

iTerm anyone?

Anything that can speed up our TDD loop has to be taken very seriously, so I tried to port the same concepts to my personal development habits.

In my day-to-day work I make use of iTerm 2, a great replacement to the default Mac terminal application. iTerm provides both split and tab sessions; furthermore, it supports the use of AppleScript to automate many aspects of its behavior.

I asked myself whether I really needed to add an "extra layer" to my usual stack — that is, tmux — or rather if I could achieve the same result without it. Turns out it was not the case.

How to communicate with iTerm

Man, I hate AppleScript. Approximately 90% of the entire time spent on this small project was just to learn the minimum necessary to write this:

1 #! /usr/bin/osascript
2 tell application "iTerm"
3   tell the current terminal
4     tell (first session Whose name contains "foo")
5       text write ("echo bar" as text)
6     end tell
7   end tell
8 end tell

This code searches in the current iTerm window for a session named "foo", and sends the command echo bar to it. As you might have guessed, we just built a bridge between vim and an iTerm session.

Welcome iTermux!

Next step was to fork the turbux plugin, rename it into itermux (how original, right?) and replace its Send_to_Tmux() function with a parametrized version of the snippet mentioned above:

 1 function! Send_to_iTerm(command)
 2   let app = 'iTerm'
 3   if exists("g:itermux_app_name") && g:itermux_app_name != ''
 4     let app = g:itermux_app_name
 5   endif
 6   let session = 'iTermux'
 7   if exists("g:itermux_session_name") && g:itermux_session_name != ''
 8     let session = g:itermux_session_name
 9   endif
10 
11   let commands =  [ '-e "on run argv"',
12                   \ '-e "tell application \"' . app . '\""',
13                   \ '-e "tell the current terminal"',
14                   \ '-e "tell (first session whose name contains \"' . session . '\")"',
15                   \ '-e "set AppleScript''s text item delimiters to \" \""',
16                   \ '-e "write text (argv as text)"',
17                   \ '-e "end tell"',
18                   \ '-e "end tell"',
19                   \ '-e "end tell"',
20                   \ '-e "end run"' ]
21 
22   let complete_command = "osascript " . join(commands, ' ') . " " . a:command
23   system(complete_command)
24 endfunction

As you can see, I've made it possible to change the name of the iTerm app and the name you want to give to the iTerm session dedicated to testing, i.e.:

1 let g:itermux_session_name = 'testing'
2 let g:itermux_app_name = 'iTerm2'

Demo Time

I've prepared a small video to show how cool it is the final result. I've been using this setup for two weeks now, and it's been so rewarding.

Feedbacks appreciated!

Download it, install it, and let us know what you think of it!

Nella stragrande maggioranza dei progetti ci si ritrova a dover gestire autorizzazioni e ruoli per gli utenti. La gemma più popolare per questo compito è senza dubbio CanCan. Mi sembra questo un ottimo esempio concreto da sfruttare per la trattazione.

Nella Wiki del progetto su Github, il buon Ryan Bates elenca un paio di possibili suggerimenti per approcciarsi al problema dei test funzionali. Nei passati progetti ho cercato di seguirli diligentemente, ma la verità è che sono esempi pessimi se seguiti nel mondo reale.

Partiamo con l'analizzare meglio i problemi.

Continua a leggere