Pensieri e parole su HCI, home computing, tecnologie desktop e sul Progetto Lobotomy

Visualizzazione post con etichetta esperienze. Mostra tutti i post
Visualizzazione post con etichetta esperienze. Mostra tutti i post

sabato 4 giugno 2011

La Sindrome di Teodoro

0 commenti
Qualche tempo addietro ho gia' citato su questo blog la mia esperienza con un anziano signore che ho avuto modo di assistere presso un corso di alfabetizzazione informatica. A distanza di mesi posso dire che il personaggio in questione pur non essendo diventato un sysadmin ha comunque acquisito una modesta dimestichezza col PC, tanto da passare le giornate a compilare fogli di calcolo su OpenOffice Calc per generare coloratissimi quanto inutili (ma evidentemente soddisfacenti) grafici. Mai piu' avrei creduto che, dati i forti limiti dimostrati all'inizio del corso (ed appunto elencati nel mio precedente post) e la distanza intellettuale tra la macchina da scrivere cui era abituato ed un computer moderno, sarebbe arrivato al punto cui e' arrivato, ma tant'e': tanto di cappello al signor Teodoro.
Ad ogni modo: questo articolo non parla di lui ma di me.
Da un po' ho acquistato un nuovo PC (anzi due, l'altro e' l'Abaco di cui ho gia' parlato), un desktop, e l'ho dotato di due monitor da 19 pollici in modo da sperimentare questa per me inedita' modalita' operativa e verificare se davvero impatta sulla produttivita'. La risposta e' "si", ma non e' neanche questo il tema del giorno.
Il punto e' che la presenza di due schermi ha fatto emergere una confusione inconscia dettata dall'abitudine: ci sono spesso due finestre a tutto schermo, ma il focus e' sempre uno solo. Mi spiego meglio: da sempre lavoro con le finestre massimizzate sul desktop, e switcho da una all'altra con la classica combinazione Alt+Tab. Ben rari sono i casi in cui tengo una finestra fluttuante sul monitor, un po' per non essere distratto da quelle sotto e un po' appunto per abitudine: come detto in passato, quando mi capita di aprire una nuova applicazione e vedere la finestra non massimizzata subito premo Alt+F10 per ingrandirla. Questo pero' implica che il mio cervello e' portato a pensare che la finestra che sto guardando e' anche quella che riceve gli input da tastiera, ovvero che ha il focus, ma questo non e' piu' vero nel momento in cui appunto ci sono due schermi con due diversi programmi aperti: il focus, o sta a destra o sta a sinistra.
Per quanto scontata sia questa considerazione, mai va sottovalutato il potere dell'abitudine.
A tutt'oggi, ovvero dopo un paio di mesi di utilizzo quotidiano del doppio monitor, ancora mi trovo ad essere afflitto dalla "Sindrome di Teodoro": se guardo una finestra sono convinto di poterci interagire direttamente, dimenticando di spostare il focus. Esattamente come succedeva al signore cui ho insegnato i rudimenti dell'informatica moderna, anche io mi trovo adesso nella sua condizione: sono portato a scrivere nelle caselle di testo semplicemente dopo averle individuate e guardate sullo schermo. Nel suo caso tale impostazione mentale era probabilmente dovuta all'abitudine alla carta e alla penna, in cui effettivamente la sequenza "trova il punto in cui scrivere / sposta la mano con la penna li' sopra / scrivi" e' un continuum omogeneo che si svolge usando un unico strumento (la penna) che funge sia da dispositivo di puntamento che di input, mentre come detto nel mio caso l'errore e' dettato dall'inclinazione al fatto di avere sempre e solo una finestra con cui interfacciarsi.
Da qualche giorno ho pertanto abilitato l'opzione "Select windows when the mouse moves over them" nel pannello di configurazione per le finestre di Gnome, e la situazione e' un pochino migliorata: muovere il cursore, e dunque il focus, da un monitor all'altro mi riesce in modo abbastanza naturale, dunque non devo stare troppo a pensarci e piu' raramente mi capita di pigiare i tasti giusti per la finestra sbagliata.
Dopo 10 anni di esperienza nell'uso del PC, e' incredibile constatare l'impatto distruttivo che comporta una piccola variazione nel proprio ambiente di lavoro...

domenica 31 ottobre 2010

La Prova

0 commenti
In questo periodo sto dando una mano presso un corso di alfabetizzazione informatica organizzato dall'Officina Informatica Libera di Torino, frequentato per lo piu' da anziani ed extracomunitari. Talvolta mi trovo ad affiancare gli utenti mentre svolgono gli esercizi mirati a fargli prendere dimestichezza con mouse e tastiera, e sin troppo spesso finisco nei paraggi di un baffuto signore in particolare.
Questo personaggio, nella sua immensa ignoranza (in senso non offensivo, ovviamente) ed ingenuita', e' la dimostrazione vivente di quando sia complicato utilizzare un computer al giorno d'oggi. Facilmente va nel panico, percui si dimentica quello che gli e' stato spiegato cinque minuti prima e tenta di intuire qual'e' l'operazione giusta da fare in un dato momento, puntualmente non riuscendoci e ripetendo l'errore che aveva gia' compiuto prima della spiegazione.
Il mio preferito e' la confusione esistente tra il cursore del mouse ed il cursore lampeggiante del testo. Spesso egli punta il mouse laddove vuole apportare una modifica in una frase (cancellare un carattere, o aggiungerne un'altro), non clicca, ma comunque pigia il tasto della tastiera corrispettivo. Applicando ovviamente tale modifica da tutt'altra parte.
Fa uscire di testa guardarlo mentre tenta di selezionare del testo usando il mouse, in quanto tale tecnica per quanto famigliare per molti e' costituita da infinite "regole" non esplicite e di non immediato apprendimento: la selezione e' monodirezionale (inizia nel punto in cui si e' iniziato a cliccare e finisce nel punto ove il cursore viene spostato, dunque non e' possibile agire contemporaneamente sopra e sotto l'inizio della selezione), deve essere eseguita in un colpo solo (tutte le righe senza mai lasciare il tasto sinistro del mouse), e' suscettibile di speciali comportamenti e un testo selezionato puo' essere spostata in blocco (dunque e' buona norma deselezionare tutto prima di tentare una nuova selezione)... Tutto questo contribuisce a far perdere l'orientamento al buon utente volenteroso (e la pazienza al volenteroso assistente che gli sta accanto), al decimo tentativo di prendere cinque righe egli ha gia' sparpagliato tutto in giro per il documento cliccando e trascinando a casaccio.
I tasti sulla tastiera sono decisamente troppi. Le lettere dell'alfabeto sono sparpagliate, ma le si puo' cercare facilmente. Gia' i tasti con due o peggio tre simboli sono complicati, perche' ogni carattere e' attivabile pigiando il relativo "modifier" (che non viene mai scelto correttamente). Il dramma e' che i simboli selezionabili con Shift non sono attivati quando e' attivo il CapsLock, dunque tutto il vantaggio di spezzare la procedura in piu' parti (pigia CapsLock, pigia tasto, ripigia CapsLock) viene perso ed anzi e' richiesto di coordinare il movimento di ben due dita (un dito fisso su Shift, l'altro sul tasto desiderato). Stendiamo un velo pietoso sui pulsanti Return e Enter, i quali sono vicini e pur facendo cose totalmente diverse riportano entrambi il disegnino della freccia diretta a sinistra...
Tutte e altre considerazioni sono emerse dopo due incontri, facendo solo input di testo vagamente formattato. Sara' dura instradare correttamente il suddetto personaggio, comunque indipendentemente dai risultati che si raggiungeranno (o piu' probabilmente non si raggiungeranno) cerchero' di osservare e registrare i comportamenti della mia cavia per trarne qualche spunto.

lunedì 21 giugno 2010

Autocompletamento poco "Auto"

0 commenti
In GTK, cosiccome suppongo in ogni altro toolkit grafico sia desktop che web, si trova GtkEntryCompletion, comoda utility per gestire l'autocompletamento delle caselle di testo. Si popola una struttura dati con gli elementi validi (pescandoli da una history, da un database o quel che e'), e quando l'utente inizia a scrivere qualcosa che combacia almeno parzialmente con uno o piu' di suddetti elementi appare la casellina a tendina da cui si puo' selezionare il testo gia' completato. Il comportamento classico della barra degli indirizzi di un browser, insomma.
Finche' ci si accontenta di far semplicemente selezionare una voce e basta va (quasi) tutto bene, un po' piu' complicato e' far triggerare dall'atto della selezione una qualche azione (nel caso specifico che mi sono trovato ad affrontare: popolare un form con i dettagli relativi al nome scelto). In quanto il widget non copre molti casi d'uso che classicamente si osservano con utenti reali.
Stando a quanto ho visto nella mia esperienza, non sono cosi' tante le persone che sfruttano davvero l'autocompletamento; la situazione classica e' appunto la barra del browser, che sicuramente e' il caso piu' facilmente osservabile in natura. Non conto piu' le volte in cui ho visto utenti scrivere per intero i loro URL, ignorando completamente la casella di selezione del completamento oppure, peggio ancora, vedendola ed usandola come riferimento per copiare a mano la stringa intera. Vuoi per ignoranza sul meccanismo inteso per la corretta fruizione di questo componente grafico, vuoi perche' molti scrivono guardando la tastiera e dunque magari non notano cosa viene proposto sul monitor, vuoi per una qualche abitudine vestigiale a non farsi aiutare dal PC, vuoi per anacronistiche velleita' amanuensi, sperare di triggerare una selezione solo ed esclusivamente con la procedura prevista (inserimento del testo, individuazione della voce completata, attivazione per mezzo di click o di selezione con le freccette direzionali e del tasto Return) e' sintomo di eccessivo ottimismo.
In questo contesto, almeno due situazioni possono capitare:
  • l'utente fa quello che ci si aspetta che faccia
  • l'utente scrive a mano la voce gia' completata, ignorando il completamento automatico, e pigia Return (universalmente inteso come "terminatore di input"), oppure Tab, oppure cliccando da qualche altra parte alla fine
Per provvedere a gestire in modo decoroso il secondo caso, occorre veramente fare i salti mortali: registrare delle callback sugli eventi di focus-out e key-press (quest'ultimo per intercettare il Return), in cui compiere a mano la ricerca del testo immesso nella casella di testo nella struttura dati che contiene i valori buoni, e se opportuno comportarsi come se l'autocompletamento fosse stato attivato come voluto. Spiegarlo a parole e' molto piu' semplice che non implementarlo davvero.
Se cosi' non si facesse, il rischio sarebbe quello di avere un nome perfettamente valido nella casella di testo ma non tutti gli altri buoni altrove. Con le conseguenze piu' nefaste: l'utente riprova piu' volte a riscrivere la stringa, non comprendendo cosa ha fatto di diverso rispetto alle spiegazioni ricevute che mostravano la comodissima e sfavillante attivazione di tutto il resto, oppure l'utente compila a mano i campi che avrebbero dovuto essere riempiti autonomamente, distruggendo la sequenza logica prevista. Nel mio caso: se il form viene popolato quando nessuna voce valida e' selezionata, viene creata una nuova entry nel database; fare un controllo postumo sull'univocita' del nome introdotto sarebbe abbastanza controproducente e frustrante per il povero tapino che nel frattempo si e' riscritto tutto quanto a manina, andando a reperirlo chissa' dove.
Abitudini e limitazioni dell'utenza sono un grande, grandissimo grattacapo, cui purtroppo ci si deve confrontare nel momento in cui si voglia realizzare una interfaccia usabile senza eccessivo sforzo dalla maggior parte delle persone. Una perdita di tempo di due ore da parte mia, che ho dovuto individuare e risolvere il problema dell'attivazione dell'autocompletamento con metodi del resto opinabili, consegue ad un piccolo risparmio di patemi moltiplicato per il numero di tutti i futuri utilizzatori del programma.

lunedì 24 maggio 2010

Pennello alla Mano

0 commenti
Lo confesso, anche se chi mi conosce come programmatore gia' lo sa: io rientro in quella (nutrita) categoria di developers che dedicano pochissimo tempo alla progettazione ed ogni volta che iniziano un nuovo software o ne modificano un'altro pesantemente aprono l'editor di testo ancor prima di avere ben chiaro cosa fare. L'unico passo intermedio tra la decisione di fare qualcosa ed iniziare a farla sta nella scelta del nome: ogni progetto che si rispetti deve avere un nome!
So perfettamente che si tratta di una pratica malsana, e piu' e piu' volte ne ho pagato le conseguenze, ma d'altro canto sono convinto che l'eccessivo grado di "ingegnerizzazione" oggi in uso nel mondo dello sviluppo sia ugualmente dannoso: una dettagliata pianificazione trasmette un senso di eccessiva sicurezza, e quando le cose sono troppo ben incastrate tra loro si rischia di non avere spazio sufficiente per aggiungere quelle correzioni e quelle modifiche che, nel mondo reale, accadono sempre e comunque in qualsiasi circostanza.
Detto cio', nell'ultimo periodo ho iniziato quantomeno a progettare le interfacce delle mie applicazioni. Direi che e' gia' un passo avanti.
Ho sempre considerato il wireframing alla stregua di qualsiasi altra forma di progettazione, ma mi sono dovuto ricredere: laddove una architettura software e' oggettivamente qualcosa di completamente fumoso e dunque imperfetto finche' non la si traspone in qualcosa in esecuzione sullo stack (per poi immancabilmente fallire perche' non era stata presa in considerazione una data situazione), una interfaccia grafica e' qualcosa di concreto, in quanto anche se cliccando sul tasto non succede nulla il tasto e' comunque li' invece di essere da un'altra parte, occupa un determinato spazio e riporta una data etichetta o icona invece che un'altra.
Il primo esperimento quasi serio l'ho fatto usando MockFlow, strumento online (in Flash) per mettere insieme mockups di pagine destinate al web: la versione gratuita ha una limitazione sul numero di progetti e pagine che si possono creare, ma poiche' quelle poche pagine hanno altezza infinita si possono aggregare insieme piu' contenuti e con un poco di pazienza il paletto viene facilmente aggirato. Il secondo tentativo, rivolto ad un programma desktop (di cui scrivero' dettagliatamente in un'altra occasione), l'ho fatto con Gazpacho: progetto ad oggi leggermente defunto, nel concetto simile a Glade (che dovro' a sua volta provare, essendo pure aggiornato alle ultime evoluzioni di GTK+), funge da editor completo "a la Visual Studio" ma essendo io un programmatore vecchio stile lo ho usato solo per farmi una idea di dove posizionare i widgets che sono andato poi ad implementare a mano.
Entrambe le esperienze si sono rivelate inaspettatamente produttive: disegnare la propria interfaccia prima di riportarla sul codice permette di avere subito una idea di cosa ci si trovera' dinnanzi e, meglio ancora, di cosa ci si vorrebbe trovare; vengono subito identificate e corrette falle estetiche e funzionali nel design, si possono sopprimere o ridefinire aggregati di elementi che nella realta' appaiono molto peggio di quanto ci si era immaginati, e ci si capacita in fretta se nel concetto originale e puramente astratto mancava un qualche dettaglio che, ai fatti, sarebbe determinante ed indispensabile. Tutto questo con un costo estremamente basso, in quanto in un paio d'ore di cliccate si ottengono risultati piu' che sufficienti per condurre una valutazione ed eventualmente ridefinire la proprio linea: tutto tempo che altrimenti verrebbe riccamente sprecato per implementare, compilare, eseguire, cancellare e re-implementare.
Gli strumenti per prototipare e costruire bozze realistiche non mancano, anzi ce n'e' una abbondanza, e val proprio la pena almeno di provarli.