[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [home] [volume] [parte]


Capitolo 130.   Typeit

Typeit(1) è un'applicazione per la verifica dell'abilità raggiunta nella scrittura (partendo dal presupposto che le mani vengano usate correttamente), funzionante attraverso un terminale a caratteri.

Typeit è costituito da due script di shell che, a sua volta, si avvalgono del programma Dialog e di altri programmi di servizio comuni. Al termine di un'esercitazione con Typeit si ottiene la stampa di alcuni indici per la valutazione dell'abilità di scrittura.

I due script di Typeit sono quasi equivalenti, distinguendosi solo per la possibilità di mostrare o meno il testo durante la digitazione. Pertanto, lo script typeit-view consente di vedere ciò che si digita, mentre typeit-blind non fa apparire l'inserimento. I due script (typeit-view e typeit-blind) possono essere collocati ovunque si voglia, nel file system, purché da lì sia possibile avviarli.

130.1   Esempio di utilizzo

La sintassi per utilizzare gli script di Typeit è molto semplice: è possibile indicare il nome di un file di testo contenente l'esercizio di digitazione, oppure si può omettere tale informazione.

typeit-view [file_lettura]
typeit-blind [file_lettura]

A titolo di esempio, si potrebbe voler usare il testo seguente come esercitazione.

Listato 130.1. Questo file dovrebbe essere disponibile presso: <allegati/a2/typeit/esopo-due-bisacce.txt>.

Le due bisacce
di Esopo
Ciascun uomo porta due bisacce, una davanti, l'altra dietro, \
  \e ciascuna delle due è piena di difetti, ma quella davanti è \
  \piena dei difetti altrui, quella dietro dei difetti dello stesso \
  \che la porta. E per questo gli uomini non vedono i difetti che vengono da loro \
  \stessi, mentre vedono assai perfettamente quelli altrui.

Ammesso che il file si chiami esopo-due-bisacce.txt, l'avvio di Typeit è molto semplice:

typeit-view esopo-due-bisacce.txt[Invio]

Oppure:

typeit-blind esopo-due-bisacce.txt[Invio]

Il programma richiede la digitazione di una riga alla volta, premendo [Invio] alla fine di ognuna. Se la riga inserita corrisponde esattamente a quella richiesta, si passa alla successiva, altrimenti, viene mostrata la riga errata e viene richiesto nuovamente l'inserimento della riga che non è venuta bene:

.-------------------------typeit---------------------------.
|                                                          |
|  Le due bisacce                                          |
| .------------------------------------------------------. |
| |                                                      | |
| `------------------------------------------------------' |
|                                                          |
|----------------------------------------------------------|
|               <  OK  >        <Cancel>                   |
`----------------------------------------------------------'

Le due bisacce[Invio]

.-------------------------typeit---------------------------.
|                                                          |
|  di Esopo                                                |
| .------------------------------------------------------. |
| |                                                      | |
| `------------------------------------------------------' |
|                                                          |
|----------------------------------------------------------|
|               <  OK  >        <Cancel>                   |
`----------------------------------------------------------'

di Esopo[Invio]

.-------------------------typeit---------------------------.
|                                                          |
|  Ciascun uomo porta due                                  |
| .------------------------------------------------------. |
| |                                                      | |
| `------------------------------------------------------' |
|                                                          |
|----------------------------------------------------------|
|               <  OK  >        <Cancel>                   |
`----------------------------------------------------------'

Ciascun uomo porta due[Invio]

...

...

.-------------------------typeit---------------------------.
|                                                          |
|  da loro stessi, mentre vedono                           |
| .------------------------------------------------------. |
| |                                                      | |
| `------------------------------------------------------' |
|                                                          |
|----------------------------------------------------------|
|               <  OK  >        <Cancel>                   |
`----------------------------------------------------------'

da loro stessi, mentre vendono[Invio]

Qui è stato commesso un errore, sostituendo la parola «vedono» con «vendono». L'errore viene segnalato e la riga va riscritta:

.-------------------------typeit---------------------------.
| !da loro stessi, mentre vendono [riga errata]            |
|  da loro stessi, mentre vedono                           |
| .------------------------------------------------------. |
| |                                                      | |
| `------------------------------------------------------' |
|                                                          |
|----------------------------------------------------------|
|               <  OK  >        <Cancel>                   |
`----------------------------------------------------------'

La riga errata è preceduta da un punto esclamativo ed è seguita dalla riga corretta da reinserire.

da loro stessi, mentre vedono[Invio]

...

...

.-------------------------typeit---------------------------.
|                                                          |
|  altrui.                                                 |
| .------------------------------------------------------. |
| |                                                      | |
| `------------------------------------------------------' |
|                                                          |
|----------------------------------------------------------|
|               <  OK  >        <Cancel>                   |
`----------------------------------------------------------'

altrui.[Invio]

Al termine dell'inserimento si ottiene automaticamente una stampa con il rapporto della digitazione, evidenziando gli errori e le righe che sono state saltate del tutto (se non si riesce a inserire una riga, è sufficiente premere [Invio] senza introdurre altro, per passare alla successiva). Con l'invio del rapporto alla stampa, Typeit termina di funzionare.

Naturalmente, si può abbandonare in qualunque momento il lavoro selezionando il pulsante grafico <Cancel>.

Ecco come potrebbe apparire la stampa del rapporto:

 Le due bisacce
 di Esopo
 Ciascun uomo porta due
 bisacce, una davanti, l'altra
 dietro, e ciascuna delle due
 è piena di difetti, ma
 quella davanti è piena dei
 difetti altrui, quella dietro
 dei difetti dello stesso che
 la porta.
 E per questo gli uomini non
 vedono i difetti che vengono
!da loro stessi, mentre vendono [riga errata]
 da loro stessi, mentre vedono
 assai perfettamente quelli
 altrui.

programma utilizzato:                   /opt/typeit/bin/typeit-view
utente:                                 appunti2
data:                                   Fri Nov  2 14:15:10 CET 2007
file:                                   esopo-due-bisacce.txt
parole contenute nel file originale:    59
caratteri contenuti nel file originale: 359
righe complessive, digitate o saltate:  16
righe errate:                           1
righe abbandonate:                      0
righe corrette:                         15
righe errate:                           6 %
righe abbandonate:                      0 %
righe corrette:                         94 %
tempo impiegato:                        0:01:03
battute virtuali al minuto:             341
parole virtuali al minuto:              56
indicatore di valutazione  50 battute:  94 %
indicatore di valutazione 100 battute:  94 %
indicatore di valutazione 150 battute:  94 %
indicatore di valutazione 200 battute:  94 %
indicatore di valutazione 250 battute:  94 %
indicatore di valutazione  20 parole:   94 %
indicatore di valutazione  40 parole:   94 %
indicatore di valutazione  60 parole:   87 %
indicatore di valutazione  80 parole:   65 %
indicatore di valutazione 100 parole:   52 %

Alla fine del rapporto appaiono in particolare degli indicatori che potrebbero essere usati per dare una valutazione numerica allo studente, ma il valore che producono dipende da una funzione che attribuisce un peso diverso alla velocità di scrittura rispetto alla correttezza della digitazione. Naturalmente questa funzione può essere modificata per definire una valutazione più conforme con il proprio metodo valutativo.

Nella valutazione automatica si considerano due aspetti, la correttezza del testo e la velocità di inserimento. In questo caso si vede una sola riga errata, inoltre tutte le righe sono state inserite (nessuna è stata abbandonata). La velocità di scrittura è stata abbastanza elevata e si potrebbe attribuire ipoteticamente un nove, anche se ci si attende una velocità di 250 battute al minuto, oppure di 40 parole al minuto. Se invece si pretende una scrittura a 100 parole al minuto, il voto ipotetico potrebbe essere solo un cinque.

130.2   Menù di file

Se si avvia Typeit senza indicare alcun file, si ottiene un menù con l'elenco di quelli presenti nella directory corrente, anche se non è detto che tutti siano adatti allo svolgimento dell'esercitazione:

.-----------------lectures--------------------.
| .---^(-)----------------------------------. |
| |   esopo-cicala-formica.txt          .   | |
| |   esopo-contadino-serpe.txt         .   | |
| |   esopo-cornacchia.txt              .   | |
| |   esopo-corvo-malato.txt            .   | |
| |   esopo-corvo-volpe.txt             .   | |
| |   esopo-due-bisacce.txt             .   | |
| |   esopo-fortuna-del-cavallo.txt     .   | |
| |   esopo-gallina-uova-oro.txt        .   | |
| |   esopo-granchio-e-volpe.txt        .   | |
| |   esopo-inverno-primavera.txt       .   | |
| `---v(+)----------------------------------' |
|                                             |
|---------------------------------------------|
|           <  OK  >      <Cancel>            |
`---------------------------------------------'

130.3   Preparazione degli esercizi

Per preparare un esercizio di digitazione, è sufficiente un file di testo. Il file può essere redatto indifferentemente secondo le convenzioni Unix o Dos, per quanto riguarda il codice di interruzione di riga; inoltre, non occorre fare attenzione agli spazi e nemmeno alla lunghezza delle righe, perché gli spazi superflui vengono eliminati automaticamente e le righe vengono impaginate a un'ampiezza massima stabilita.

La cosa che conta veramente nel file è che deve essere realizzato utilizzando la codifica UTF-8, ma di conseguenza, anche la configurazione locale deve prevedere tale codifica per la rappresentazione dei caratteri.

130.4   Il file «typeit-view»

Il file typeit-view dovrebbe essere disponibile presso <allegati/a2/typeit/typeit-view>, ma in ogni caso è visibile nel listato successivo:

#!/bin/sh

P_PROGRAM_NAME="$0"
P_INPUT_FILE="$1"
P_SPEED_PERCENT="100"
P_CORRECT_PERCENT="100"
P_MAX_COLUMNS="30"
P_DIALOG_WIDTH=$(($P_MAX_COLUMNS+30))
P_DIALOG_HEIGHT=10
P_DIALOG_TYPE="--inputbox"
#P_DIALOG_TYPE="--passwordbox"
P_DIALOG_TEMP=`tempfile`
touch $P_DIALOG_TEMP
#
#
#
filter () {
    #
    # «´» --> «'»   U+00B4 --> U+0027
    # «’» --> «'»   U+2019 --> U+0027
    #
    cat \
    | sed "s/´/'/g" \
    | sed "s/’/'/g" \
    | sed "s/ / /g" \
    | tr "\r" " " \
    | tr "\t" " " \
    | sed "s/  */ /g" \
    | sed "s/^  *//g" \
    | sed "s/  *$//g"
}
#
#
#
input_filter () {
    local INPUT_FILE="$1"
    local FILTERED_FILE="$2"
    #
    # «´» --> «'»   U+00B4 --> U+0027
    # «’» --> «'»   U+2019 --> U+0027
    #
    cat "$INPUT_FILE" \
        | filter \
        | fold -s -w $P_MAX_COLUMNS \
        > $FILTERED_FILE
}
#
#
#
evaluation () {
    local EXPECTED_SPEED="$1"
    local SPEED="$2"
    local CORRECTNESS="$3"
    local EVALUATION_SPEED=""
    local EVALUATION_CORRECT=""
    #
    if [ 0$SPEED -gt 0$EXPECTED_SPEED ]
    then
        SPEED="$EXPECTED_SPEED"
    fi
    #
    EVALUATION_SPEED=$(($SPEED*$P_SPEED_PERCENT/$EXPECTED_SPEED))
    #
    EVALUATION_CORRECT=$(($CORRECTNESS*$P_CORRECT_PERCENT/100))
    #
    echo $(($EVALUATION_SPEED*$EVALUATION_CORRECT/100))
}
#
#
#
report () {
    local INPUT_FILTERED="$1"
    local INPUT_FILE="$2"
    local OUTPUT_FILE="$3"
    local TIME_START="$4"
    local TIME_END="$5"
    local SOURCE_WORDS=""
    local SOURCE_CHARACTERS=""
    local TYPED_LINES=""
    local ERROR_LINES=""
    local ABANDONED_LINES=""
    local CORRECT_LINES=""
    local ERROR=""
    local ABANDONED=""
    local CORRECTNESS=""
    local ELAP_T=""
    local ELAP_H=""
    local ELAP_M=""
    local ELAP_S=""
    local SPEED_WORDS=""
    local SPEED_CHARACTERS=""
    #
    local EVAL_1=""
    local EVAL_2=""
    local EVAL_3=""
    local EVAL_4=""
    local EVAL_5=""
    local EVAL_6=""
    local EVAL_7=""
    #
    local EVAL_W1=""
    local EVAL_W2=""
    local EVAL_W3=""
    local EVAL_W4=""
    local EVAL_W5=""
    local EVAL_W6=""
    local EVAL_W7=""
    #
    local TODAY=`date`
    #
    SOURCE_WORDS=`wc -w $INPUT_FILTERED | sed "s/^\([0-9]*\) .*$/\1/"`
    SOURCE_CHARACTERS=`wc -m $INPUT_FILTERED | sed "s/^\([0-9]*\) .*$/\1/"`
    TYPED_LINES=`wc -l $OUTPUT_FILE | sed "s/^\([0-9]*\) .*$/\1/"`
    ERROR_LINES=`cat $OUTPUT_FILE | grep "^!" | wc -l | sed "s/^\([0-9]*\) .*$/\1/"`
    ABANDONED_LINES=`cat $OUTPUT_FILE | grep "^?" | wc -l | sed "s/^\([0-9]*\) .*$/\1/"`
    CORRECT_LINES=`cat $OUTPUT_FILE | grep -v "^[!?]" | wc -l | sed "s/^\([0-9]*\) .*$/\1/"`
    ERROR=$(($ERROR_LINES*100/$TYPED_LINES))
    ABANDONED=$(($ABANDONED_LINES*100/$TYPED_LINES))
    CORRECTNESS=$((100-$ERROR-$ABANDONED))
    ELAP_T=$(($TIME_END-$TIME_START))
    ELAP_H=$(($ELAP_T/60/60))
    ELAP_M=$((($ELAP_T-($ELAP_H*60*60))/60))
    ELAP_S=$(($ELAP_T-($ELAP_H*60*60)-($ELAP_M*60)))
    ELAP_M=`printf "%02d" "$ELAP_M"`
    ELAP_S=`printf "%02d" "$ELAP_S"`
    SPEED_CHARACTERS=$((($SOURCE_CHARACTERS*60)/$ELAP_T))
    SPEED_WORDS=$((($SOURCE_WORDS*60)/$ELAP_T))
    #
    EVAL_1=`evaluation  50 $SPEED_CHARACTERS $CORRECTNESS`
    EVAL_2=`evaluation 100 $SPEED_CHARACTERS $CORRECTNESS`
    EVAL_3=`evaluation 150 $SPEED_CHARACTERS $CORRECTNESS`
    EVAL_4=`evaluation 200 $SPEED_CHARACTERS $CORRECTNESS`
    EVAL_5=`evaluation 250 $SPEED_CHARACTERS $CORRECTNESS`
    #
    EVAL_W1=`evaluation  20 $SPEED_WORDS $CORRECTNESS`
    EVAL_W2=`evaluation  40 $SPEED_WORDS $CORRECTNESS`
    EVAL_W3=`evaluation  60 $SPEED_WORDS $CORRECTNESS`
    EVAL_W4=`evaluation  80 $SPEED_WORDS $CORRECTNESS`
    EVAL_W5=`evaluation 100 $SPEED_WORDS $CORRECTNESS`
    #
    echo ""                                                     >> $OUTPUT_FILE
    echo "programma utilizzato:                   $P_PROGRAM_NAME" \
                                                                >> $OUTPUT_FILE
    echo "utente:                                 $USER"        >> $OUTPUT_FILE
    echo "data:                                   $TODAY"       >> $OUTPUT_FILE
    echo "file:                                   $INPUT_FILE"  >> $OUTPUT_FILE
    echo "parole contenute nel file originale:    $SOURCE_WORDS" \
                                                                >> $OUTPUT_FILE
    echo "caratteri contenuti nel file originale: $SOURCE_CHARACTERS" \
                                                                >> $OUTPUT_FILE
    echo "righe complessive, digitate o saltate:  $TYPED_LINES" >> $OUTPUT_FILE
    echo "righe errate:                           $ERROR_LINES" >> $OUTPUT_FILE
    echo "righe abbandonate:                      $ABANDONED_LINES" >> $OUTPUT_FILE
    echo "righe corrette:                         $CORRECT_LINES" \
                                                                >> $OUTPUT_FILE
    echo "righe errate:                           $ERROR %"     >> $OUTPUT_FILE
    echo "righe abbandonate:                      $ABANDONED %" >> $OUTPUT_FILE
    echo "righe corrette:                         $CORRECTNESS %" \
                                                                >> $OUTPUT_FILE
    echo "tempo impiegato:                        $ELAP_H:$ELAP_M:$ELAP_S" \
                                                                >> $OUTPUT_FILE
    echo "battute virtuali al minuto:             $SPEED_CHARACTERS" \
                                                                >> $OUTPUT_FILE
    echo "parole virtuali al minuto:              $SPEED_WORDS" >> $OUTPUT_FILE
    echo "indicatore di valutazione  50 battute:  $EVAL_1 %"    >> $OUTPUT_FILE
    echo "indicatore di valutazione 100 battute:  $EVAL_2 %"    >> $OUTPUT_FILE
    echo "indicatore di valutazione 150 battute:  $EVAL_3 %"    >> $OUTPUT_FILE
    echo "indicatore di valutazione 200 battute:  $EVAL_4 %"    >> $OUTPUT_FILE
    echo "indicatore di valutazione 250 battute:  $EVAL_5 %"    >> $OUTPUT_FILE
    echo "indicatore di valutazione  20 parole:   $EVAL_W1 %"   >> $OUTPUT_FILE
    echo "indicatore di valutazione  40 parole:   $EVAL_W2 %"   >> $OUTPUT_FILE
    echo "indicatore di valutazione  60 parole:   $EVAL_W3 %"   >> $OUTPUT_FILE
    echo "indicatore di valutazione  80 parole:   $EVAL_W4 %"   >> $OUTPUT_FILE
    echo "indicatore di valutazione 100 parole:   $EVAL_W5 %"   >> $OUTPUT_FILE
}
#
#
#
print () {
    local OUTPUT_FILE="$1"
    #
    # Enscript is not able to work with UTF-8.
    #
    recode -f UTF-8..Latin1 $OUTPUT_FILE
    #
    # Convert to PostScript.
    #
    cat $OUTPUT_FILE \
        | /usr/bin/enscript -X 88591 -1 -M a4 -f Courier@8.5/9.5 \
          --header "%N - %n - %F %C - p. \$%/\$= - $IPV4" \
          --header-font="Times-Roman@9/12" \
          --margin=72:72:72:72 -o - 2> "/dev/null" \
        > $OUTPUT_FILE.ps
    #
    lpr $OUTPUT_FILE.ps
}
#
#
#
typeit_loop () {
    local ORIGINAL_LINE=""
    local WRITTEN_LINE=""
    local ERROR_LINE=""
    #
    while read ORIGINAL_LINE
    do
        if [ "$ORIGINAL_LINE" = "" ]
        then
            continue
        else
            while [ "$ORIGINAL_LINE" != "$WRITTEN_LINE" ]
            do
                WRITTEN_LINE=""
                if dialog  \
                    --title "typeit" \
                    $P_DIALOG_TYPE \
                    "$ERROR_LINE\n $ORIGINAL_LINE" \
                    $P_DIALOG_HEIGHT $P_DIALOG_WIDTH \
                    "$WRITTEN_LINE" \
                    2> $P_DIALOG_TEMP
                then
                    WRITTEN_LINE=`cat $P_DIALOG_TEMP | filter`
                    echo "" > $P_DIALOG_TEMP
                    #
                    if   [ "$WRITTEN_LINE" = "" ]
                    then
                        ERROR_LINE="?$ORIGINAL_LINE     [riga non inserita]"
                        echo "$ERROR_LINE" 1>&2
                        break
                    elif [ "$ORIGINAL_LINE" = "$WRITTEN_LINE" ]
                    then
                        ERROR_LINE=""
                        echo " $WRITTEN_LINE" 1>&2
                        break
                    else                        
                        ERROR_LINE="!$WRITTEN_LINE      [riga errata]"
                        echo "$ERROR_LINE" 1>&2
                    fi
                else
                    exit
                fi
            done
        fi
    done        
}
#
#
#
menu () {
    local MENU_LIST=""
    #
    for f in *
    do
        if [ -r "$f" ]
        then
            MENU_LIST="$MENU_LIST $f ."
        fi
    done
    #
    if dialog   \
        --clear \
        --title "lectures" \
        --menu "" \
        0 0 0 \
        $MENU_LIST \
        2> $P_DIALOG_TEMP
    then
        P_INPUT_FILE=`cat $P_DIALOG_TEMP`
        echo "" > $P_DIALOG_TEMP
    else
        exit
    fi
}
#
#
#
main () {
    local INPUT_FILTERED
    local TIME_START=""
    local TIME_END=""
    local OUTPUT_FILE=`tempfile`
    touch $OUTPUT_FILE
    local INPUT_FILTERED=`tempfile`
    touch $INPUT_FILTERED
    #
    if [ -r "$P_INPUT_FILE" ]
    then
        true
    else
        menu
    fi
    #
    if [ -f "$P_INPUT_FILE" ] && [ -r "$P_INPUT_FILE" ]
    then
        input_filter "$P_INPUT_FILE" "$INPUT_FILTERED"
        TIME_START=`date +%s`
        typeit_loop < "$INPUT_FILTERED" 2>> $OUTPUT_FILE
        TIME_END=`date +%s`
        report "$INPUT_FILTERED" "$P_INPUT_FILE" "$OUTPUT_FILE" \
               "$TIME_START" "$TIME_END"
        print $OUTPUT_FILE
    else
        echo "Cannot access file \"$P_INPUT_FILE\"!"
    fi
    if [ -f $OUTPUT_FILE ]
    then
        rm $OUTPUT_FILE
    fi
    if [ -f $OUTPUT_FILE.ps ]
    then
        rm $OUTPUT_FILE.ps
    fi
    if [ -f $INPUT_FILTERED ]
    then
        rm $INPUT_FILTERED
    fi
}
#
# Start of program
#
main "$1"
rm $P_DIALOG_TEMP
#

130.5   Il file «typeit-blind»

Lo script typeit-blind dovrebbe essere disponibile presso <allegati/a2/typeit/typeit-blind>, ma in ogni caso si tratta di una piccola variante rispetto a typeit-view, con lo scopo di non mostrare la digitazione in corso. In pratica, la modifica consiste in questo:

...
P_DIALOG_HEIGHT=10
#P_DIALOG_TYPE="--inputbox"
P_DIALOG_TYPE="--passwordbox"
P_DIALOG_TEMP=`tempfile`
touch $P_DIALOG_TEMP
...

1) Typeit   GNU GPL


Appunti di informatica libera 2008 --- Copyright © 2000-2008 Daniele Giacomini -- <appunti2 (ad) gmail·com>


Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome typeit.htm

[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [home]

Valid ISO-HTML!

CSS validator!

Gjlg Metamotore e Web Directory