Ricapitolando, la tabella squadre:

• id_squadra
• nome

tabella partite

• id_partita
• id_casa
• id_ospiti
• gol_casa
• gol_ospiti

Probabilmente, la prima soluzione che ci verrebbe in mente sarebbe quella di scrivere qualcosa del genere:

SELECT *
FROM partite
JOIN squadre ON partite.id_casa = squadre.id_squadra
JOIN squadre ON partite.id_ospiti = squadre.id_squadra

Qualcuno subito potrebbe notare che questa query andrà sicuramente in errore, in quanto così facendo stiamo chiedendo all’interprete SQL di eseguire due JOIN diverse sulla stessa tabella e sullo stesso campo, questo non gli piacerà e ci ritornerà un errore del tipo:

#1066 – Not unique table/alias: ’squadre’

La soluzione più veloce per risolvere questo problema consiste nel rinominare le tabelle su cui fare i due JOIN, ovvero rinominare la tabella squadre in modo da far credere all’interprete SQL che sia una tabella diversa. Ovvero:

SELECT *
FROM partite
JOIN squadre AS sq_casa ON partite.id_casa = sq_casa.id_squadra
JOIN squadre AS sq_ospite ON partite.id_ospite = sq_ospite.id_squadra

In questo modo è come se avessimo 3 tabelle: partite, sq_casa, sq_ospite su cui potremmo operare indipendentemente.

• 3 caratteri per il cognome
• 3 caratteri per il nome
• 5 caratteri per la data di nascita e il sesso
• 4 caratteri per il luogo di nascita
• 1 carattere di controllo

Spesso, in particolare se ci troviamo a dover programmare form di registrazione, ci troveremo prima o poi a doverne controllare la correttezza. Sebbene in pochi lo sanno, il codice fiscale, ha un algoritmo (intrinseco) di verifica della correttezza abbastanza robusto. In questo articolo vedremo concettualmente come funziona questo algoritmo di controllo e come implementarlo in un linguaggio di programmazione. Verrà utilizzato Java per la scrittura dell’algoritmo ma non dovrebbe essere complicato emularlo in altri linguaggi, se avete realizzato una versione in un linguaggio di programmazione diverso da Java potete postarlo tra i commenti e lo inserirò nell’articolo.

Il concetto

Supponendo che ci sia stato inviato un codice fiscale, il nostro algoritmo dovrà controllarne la correttezza sintattica, (ovvero che non ci siano numeri nelle posizioni che dovrebbero essere occupate da lettere) e semantica (ovvero che il carattere di controllo risulti “solidale” rispetto agli altri 15). Per controllare la correttezza sintattica del codice fiscale passato useremo le espressioni regolari, mentre per la correttezza semantica costruiremo un algoritmo apposito per calcolare il sedicesimo carattere sfruttando i 15 forniti. L’esito del confronto tra il carattere di controllo inviato e quello calcolato rileverà la correttezza o meno del codice.

L’algoritmo

La correttezza semantica del codice fiscale, come abbiamo già detto, si basa sulla presenza del sedicesimo carattere di controllo, ricavato attraverso una serie di operazioni X sui 15 caratteri precedenti. Se il sedicesimo carattere inserito dall’utente è diverso da quello risultante dalle operazioni X allora il codice è semanticamente non corretto. In cosa consistono queste operazioni? Si converte ognuno dei 15 caratteri del codice in un valore numerico rispettando due distinte tabelle di conversione a seconda che stiamo convertendo un carattere pari o un carattere dispari. Ecco le tabelle di conversione:

Una volta completata la fase precedente avremo 15 numeri, li sommeremo tra loro e il risultato ottenuto lo divideremo per 26. Il resto di tale divisione restituirà ovviamente un numero intero che dovrà essere trasformato in un carattere alfabetico grazie ad un ulteriore tabella di trasformazione. La tabella è in realtà la tabella dei numeri pari, priva dei caratteri numerici e con i soli caratteri alfabetici.

Se il carattere ricavato coincide col sedicesimo carattere fornito dall’utente il codice risulterà semanticamente corretto.

L’algoritmo in Java

package validatorecodicefiscale;

import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;

public class ValidatoreCodiceFiscale {
    public void validaCF(String cf) throws CFException{
       /* espr. regolare per controllare la correttezza sintattica del CF */
       String regex = "[a-zA-Z]{6}[0-9]{2}[a-zA-Z][0-9]{2}[a-zA-Z][0-9]{3}[a-zA-Z]";
       int somma = 0;

       /* Creazione dell'HashMap che realizza l'associazione chiave valore per
       i caratteri dispari */
       Map chrDispari = new HashMap();
       chrDispari.put("0", "1");
       chrDispari.put("1", "0");
       // ...
       chrDispari.put("Y", "24");
       chrDispari.put("Z", "23");

       /* HashMap che realizza l'associazione chiave-valore per i caratteri
        pari all'interno del codice fiscale. */
       Map chrPari = new HashMap();
       chrPari.put("0", "0");
       chrPari.put("1", "1");
       // ...
       chrPari.put("Y", "24");
       chrPari.put("Z", "25");

       /* HashMap che associa un valore numerico per ogni carattere che potrebbe
        essere presente come ultimo carattere del codice fiscale */
       Map chrControllo = new HashMap();
       chrControllo.put("0", "A");
       chrControllo.put("1", "B");
       // ...
       chrControllo.put("24", "Y");
       chrControllo.put("25", "Z");

       /* Effettua la somma di tutti i valori ricavati da ogni singolo carattere
        del CF. Se il carattere è pari, il valore è prelevato dall'HashMap dei
        numeri pari, dispari altrimenti. */
       for(int i=0; i<15; i++) {
           if (i % 2 == 1)
               {
                    somma += Integer.parseInt((String)
                            chrPari.get(Character.toString(cf.charAt(i))));
               }
           else
               {
                    somma += Integer.parseInt((String)
                            chrDispari.get(Character.toString(cf.charAt(i))));
               }
       }

       /* Calcolo l'esatto carattere di controllo in base al codice fiscale
        fornito dall'utente */
       String strControlloCalcolato = (String)chrControllo.get(""+somma%26);
       Character chrControlloCalcolato = strControlloCalcolato.charAt(0);

       /* Ricavo il carattere di controllo fornito dall'utente */
       Character chrControlloInserito = cf.charAt(15);

       if (!Pattern.matches(regex, cf) ||
           !chrControlloInserito.equals(chrControlloCalcolato)
          )
                throw new CFException();
    }
}

Le tre HashMap sono state accorciate nel listato sopra per ovvi motivi di spazio, ma seguendo le giuste tabelle non sarà un problema ricrearle. Nel caso in cui il codice passato dall’utente sarà errato l’algoritmo solleverà un’eccezione definita come segue:

package validatorecodicefiscale;

public class CFException extends Exception {

    public CFException() {
        super("Errore: Il Codice Fiscale inseirto non è valido.");
    }
}

La definizione dell’eccezione è volutamente semplice, in quanto il nostro scopo era quello di comprendere come poter controllare la validità del codice fiscale, non ci perderemo dunque in argomenti collaterali. Per chiunque volesse approfondire la conoscenza delle eccezioni consiglio di leggere questo link: http://www.claudiodesio.com/java/excs.htm. Una volta che abbiamo scritto l’algoritmo di controllo e definito l’eccezione che l’algoritmo potrebbe sollevare, l’unica cosa che ci resta da fare è implementarlo.

ValidatoreCodiceFiscale v = new ValidatoreCodiceFiscale();
        try {
            v.validaCF("CODICEFISCALE");
        } catch (CFException ex) {
            System.out.println("Errore di sintassi e/o di semantica.");
        }

Per un programmatore alle prime armi, volenteroso e con molta voglia di imparare c’è sempre l’ostacolo di “sì, ma che cosa programmo?”. Effettivamente seguendo le guide che vengono proposte sui libri del codice scelto, nelle prime 100 pagine viene proposto il classico “Hello World” e poco di più. Ma un geek non può mettersi davanti ad un libro ed aspettare che la conoscenza piova dal cielo… un vero geek la conoscenza se la costruisce!

Per quelli che vogliono avvicinarsi al mondo Java c’è un “programma giochino” che permetterà di imparare divertendosi (soprattutto divertendosi anche dopo aver imparato): Robocode. Robocode venne proposto inizialmente dall’IBM (non so bene cosa se ne facesse l’IBM di una cosa simile, probabilmente era per il settore di ricerca IBM) e, nel tempo è stato proposto in diversi linguaggi (la prima sintassi del gioco che vidi era in C). Sostanzialmente, quello che un “giocatore” deve fare, è crearsi il proprio robottino (nella versione per java è più un carroarmato che non un robot) e buttarlo in un arena per farlo combattere contro altri. La progettazione del robottino corrisponde nient’altro che alla scrittura del codice che gli permetta di muoversi e di reagire agli eventi. Quindi è possibile per esempio, impostare una traiettoria inziale del robot, come può essere “avanti alla velocità x” e poi intercettare eventuali eventi al fine di cambiare il comportamento della propria creatura. Per esempio se scopro dove si trova il mio avvessario, posso fare in modo che il mio robottino si metta ad inseguirlo sparandogli, oppure, per evitare che sia lui a vincere lo farò inseguire a zig-zag o qualasiasi cosa possa venirvi in mente. Assicuro che il divertimento, anche per uno come me che il Java lo usa ormai da qualche anno, è assicurato… e la vittoria sui vostri amici non ha prezzo!

Le battaglie, soprattutto quelle che fate online, contro i robo-programmatori di tutto il mondo, si dividono in categorie. Il vostro robot potrà essere Megabots se non viene imposta nessuna restrizione alla dimensione del vostro file compilato (anche 10 Mbyte di robot va bene); Minibots impone una dimensione inferiore a 1500 bytes; Microbots dimensione inferiore a 750 bytes; Nanobots inferiore 250 bytes. E’ ovvio che più la dimensione del file deve essere ridotta, meno cose sarà possibile far fare al robot, o comunque qui si vedrà chi dei programmatori riesce ad ottimizzare al meglio il codice, facendo cioè fare molte cose in poche righe di codice. Chi si aggiudicherà la coppa di “miglior programmatore dell’anno” distruggendo tutti gli avversari/colleghi?

Per qualsiasi informazione, oltre al sito ufficiale di Robocode, vi rimando anche a questa pagina su wikipedia che contiene una serie di utili link per trovare risorse per giocare.

Finita la citazione dal post di geekissimo annuncio che ormai è quasi pronto un tutorial in cui sarannno spiegate le varie interfacce di Robocode e come creare il primo robot.

Per passaggio di parametri si intende l’operazione tramite cui, durante la fase di definizione di una funzione/metodo associamo ad essa dei parametri formali. Al momento dell’esecuzione del metodo/funzione tali parametri non saranno più parametri formali ma parametri attuali. Il passaggio di parametri ad una funzione, in programmazione, può avvenire in due modi, per valore o per indirizzo. Supponiamo, in questo articolo, di voler realizzare una funzione che prenda in input due variabili e ne scambi il valore. Realizzeremo il tutto in C (dopo spiegherò anche perché C e non Java).

Passaggio di parametri per valore

L’esempio che vogliamo realizzare, è molto semplice, e anche se fossimo dei programmatori alle prime armi non ci porterebbe via molto tempo. Creeremo dunque il nostro programma e all’interno definiremo una funzione chiamata swap che prende come parametri formali due variabili e ne scambia i valori.

#include <stdio.h>

void swap(int, int);

int main()
{
    int x = 2;
    int y = 4;
    printf("output: x=%d, y=%d\n", x, y); // output: x=2, y=4
    swap(x, y); // x e y sono parametri attuali di swap
    printf("output: x=%d, y=%d\n", x, y); // output: x=2, y=4
    return 0;
}

void swap(int a, int b) // a e b sono parametri formali di swap
{
   int tmp;
   tmp = a;
   a = b;
   b = tmp;
}

Come tutti potrete vedere in questo caso le due chiamate alla funzione printf producono lo stesso output anche se tra le due abbiamo chiamato swap. Come è possibile? Un programmatore meno esperto potrebbe pensare che la causa del problema sia che in realtà la funzione swap è scritta male, ma non è questo il punto. I meno fiduciosi possono copiare il corpo della funzione swap ed incollarla tra le due chiamate a printf. Compilando e rieseguendo il programma la seconda printf dimostrerà che lo scambio c’è stato e che quindi la funzione swap era corretta. Cosa c’era allora che non andava? La risposta è intrinseca al meccanismo che i linguaggi di programmazione come il C usano nel passaggio dei parametri. In C, salvo nostre “manipolazioni”, i parametri vengono passati per valore, questo significa che al momento dell’esecuzione della funzione swap i parametri attuali vengono copiati e durante il ciclo di vita di swap saranno sempre e solo le copie ad essere modificate. Al termine di vita della funzione cesseranno di esistere anche le copie dei parametri attuali. La seconda printf confermerà che nulla è cambiato nelle nostre variabili.

Passaggio di parametri per indirizzo (o per riferimento)

Un modo per evitare il problema precedente esiste e fa ricorso all’uso dei puntatori. Grazie ad essi possiamo puntare all’area di memoria (indirizzo) dove sono contenuti i valori delle variabili che vogliamo modificare. A questo punto quando inizierà il ciclo di vita della funzione swap non verranno modificate delle copie dei parametri attuali come avveniva prima, ma il valore contenuto in un indirizzo di memoria. Ecco perché questo passaggio di parametri vien detto “passaggio per indirizzo”. Il nostro programma dovrà essere quindi modificato per assecondare tale logica:

#include <stdio.h>

void swap(int *, int *);

int main()
{
    int x = 2;
    int y = 4;
    printf("output: x=%d, y=%d\n", x, y); // output: x=2, y=4
    swap(&x, &y); // x e y sono parametri attuali di swap e sono gli indirizzi di x e y
    printf("output: x=%d, y=%d\n", x, y); // output: x=4, y=2
    return 0;
}

void swap(int *a, int *b) // a e b sono parametri formali di swap di tipo puntatore a intero
{
   int tmp;
   tmp = *a;
   *a = *b;
   *b = tmp;
}

E per quel che riguarda Java?

Per quel che riguarda Java come al solito c’è qualche mito da sfatare. Il più famoso è quello che sostiene che i tipi primitivi siano passati per valore e gli oggetti per indirizzo. Niente di più errato! E’ corretto dire invece che in Java tutto è passato per valore. Infatti, per rendere il tutto quanto più semplice possibile non esiste il passaggio per riferimento (ecco perchè l’esempio è in C), così come confermato dallo stesso James Gosling, uno degli inventori di Java:

Some people will say incorrectly that objects are passed “by reference.” In programming language design, the term pass by reference properly means that when an argument is passed to a function, the invoked function gets a reference to the original value, not a copy of its value. If the function modifies its parameter, the value in the calling code will be changed because the argument and parameter use the same slot in memory…. The Java programming language does not pass objects by reference; it passes object references by value. Because two copies of the same reference refer to the same actual object, changes made through one reference variable are visible through the other. There is exactly one parameter passing mode — pass by value — and that helps keep things simple.

James Gosling – The Java Programming Language, 4th Edition

Facendo 2+2, ne viene che l’unico modo che abbiamo per effettuare uno scambio di variabile in Java è quello di farlo senza usare metodi.

Groovy è un linguaggio di programmazione orientato agli oggetti nato con la pretesa di far avvicinare la robustezza di Java alla semplicità ed alla velocità di sviluppo dei linguaggi più moderni come Python, Ruby e i meno moderni Perl e SmallTalk. La particolarità è che stavolta non ci troviamo dinanzi all’ennesimo linguaggio di programmazione così come siamo abituati a considerare, bensì un linguaggio di programmazione per l’ambiente Java, ad esso alternativo e completamente interoperabile (o quasi). Possiamo includere codice Java in codice Groovy, di seguito entrambi verranno semi-compilati in bytecode per poi essere eseguito da qualsiasi JVM. Gli sviluppatori Groovy affermano che la curva di apprendimento per passare da Java a Groovy è prossima allo zero. Vediamo se è vero e vediamo se davvero lo sviluppo in Groovy è più agile. Quella che segue è una lista delle principali differenze, spero sia quanto più completa possibile, se mi è sfuggito qualcosa di interessante basta un commento:

Import di default

A differenza di Java, vengono importate di default una serie di librerie che sono:

java.io.*
java.lang.*
java.math.BigDecimal
java.math.BigInteger
java.net.*
java.util.*
groovy.lang.*
groovy.util.*

Array

Sebbene la sintassi sia molto simile a Java, non useremo le parentesi graffe per dichiarare un array, bensì le quadre:

int[] a = {1,2,3};   // Sintassi Java
int[] a = [1,2,3];     // Sintassi Groovy

Ciclo for

Il ciclo for non può essere scritto come siamo abituati a fare, ma abbiamo delle sintassi alternative:

// Sintassi Java
for (int i=0; i < len; i++) {...}

// Alternative Groovy
for (i in 0..len-1) {...}
for (i in 0..<len) {...}
len.times {...}

Per ora, non so se sia una scelta voluta, o dovuta a problemi di sviluppo, nella testata del for può essere aggiunta una sola variabile di incremento.

Liste

In Java una list è una collezione ordinata, come l’array ha un indice per ogni elemento ed ammette duplicati. Le principali implementazioni di list sono ArrayList, Vector e LinkedList. Qualsiasi implementazione vogliamo usare, in Java, va per l’appunto istanziata:

ArrayList list = new ArrayList(3);
list.add(5);
list.add(6);
list.add(7);
list.add(8);

In Groovy non abbiamo bisogno di crearle con new:

def list = [5, 6, 7, 8]

Supporto ai linguaggi di Markup

import groovy.xml.MarkupBuilder
    def myXMLDoc = new MarkupBuilder()
    myXMLDoc.workbook {
       worksheet(caption:"Employees") {
          row(fname:"John", lname:"McDoe")
          row(fname:"Nancy", lname:"Davolio")
       }
       worksheet(caption:"Products") {
          row(name:"Veeblefeetzer", id:"sku34510")
          row(name:"Prune Unit Zappa", id:"sku3a550")
       }
    }
    println myXMLDoc

produce in output:

<workbook>
  <worksheet caption='Employees'>
    <row fname="John" lname="McDoe" />
    <row fname="Nancy" lname="Davolio" />
  </worksheet>
  <worksheet caption='Products'>
    <row name="Veeblefeetzer" id="sku34510" />
    <row name="Prune Unit Zappa" id="sku3a550" />
  </worksheet>
</workbook>

Se avessimo voluto farlo in Java:

import java.io.StringWriter;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class XMLFun {

        public static void main(String[] args) throws Exception {
                TransformerFactory factory = TransformerFactory.newInstance();
                factory.setAttribute("indent-number", 2);
                Transformer trans = factory.newTransformer();
                trans.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
                trans.setOutputProperty(OutputKeys.INDENT, "yes");

                DocumentBuilderFactory dbfac = DocumentBuilderFactory.newInstance();
                DocumentBuilder docBuilder = dbfac.newDocumentBuilder();
                Document doc = docBuilder.newDocument();
                Element workbook = doc.createElement("workbook");
                doc.appendChild(workbook);
                Element worksheet = doc.createElement("worksheet");
                worksheet.setAttribute("caption", "Employees");
                workbook.appendChild(worksheet);
                Element row = doc.createElement("row");
                row.setAttribute("fname", "John");
                row.setAttribute("lname", "McDoe");
                worksheet.appendChild(row);
                row = doc.createElement("row");
                row.setAttribute("fname", "Nancy");
                row.setAttribute("lname", "Davolio");
                worksheet.appendChild(row);

                worksheet = doc.createElement("worksheet");
                worksheet.setAttribute("caption", "Products");
                workbook.appendChild(worksheet);
                row = doc.createElement("row");
                row.setAttribute("name", "Veeblefeetzer");
                row.setAttribute("id", "sku34510");
                worksheet.appendChild(row);
                row = doc.createElement("row");
                row.setAttribute("name", "Prune Unit Zappa");
                row.setAttribute("id", "sku3a550");
                worksheet.appendChild(row);

                StringWriter writer = new StringWriter();
                StreamResult out = new StreamResult(writer);
                DOMSource dsource = new DOMSource(doc);
                trans.transform(dsource, out);
                System.out.println(writer.toString());
        }
}

Altre differenze altrettanto importanti sono: la possibilità di non terminare le istruzioni con un punto e virgola, questo va fatto solo se scriviamo più istruzioni su una stessa riga; l’istruzione return non è obbligatoria; metodi e classi sono public di default; non c’è differenza tra eccezioni checked e unchecked; supporto nativo alle espressioni regolari; possibilità di tipizzazione statica o dinamica per variabili e metodi. Per maggiori informazioni consiglio di dare un’occhiata al sito ufficiale del progetto, http://groovy.codehaus.org/, dove possiamo trovare preziose informazioni e documenti che ho usato per creare questo articolo. Detto questo non resta che mostrare il classico “Hello World”.

class Greet {
  def name
  Greet(who) { name = who[0].toUpperCase() + who[1..-1] }
  def salute() { println "Hello $name!" }
}

g = new Greet('world')  // create object
g.salute()               // Output "Hello World!"

Sebbene le somiglianze con Java siano evidenti, è anche vero che per un programmatore esperto abituato con la sintassi Java è noiso per i primi tempi capire come scrivere il codice e magari fare continuamente riferimento alla documentazione per creare una classe, un metodo o un ciclo for. Nonostante tutto, penso che questo “spreco” di tempo iniziale sarà ben ripagato nel futuro. L’esempio del documento XML è quello più lampante di quanto può essere veloce programmare con Groovy.
Intanto la comunità sta apprezzando il progetto, tant’è che a corredo sono nati anche vari framework, Grails è il primo che mi viene in mente. Non resta dunque che iniziare a provare…

PHP

• Potente Editor PHP (Completamente del codice, controllo sintattico e semantico con evidenziazione del codice)
• Supporto per la notazione heredoc e PHTML
• Debugging con Xdebug
• Generatore automatico di query per MySQL database

JavaScript e Ajax

• Editor e debugger per JavaScript
• Gestore di librerie JavaScript
• Inclusione di alcuni dei principale framework ajax in circolazione: Yahoo UI, Woodstock, jQuery, Dojo, Scriptaculous, Prototype
• Migliorato l’editor CSS

Java EE & Sviluppo Web

• Migliorato il supporto per Spring, Hibernate, JSF, JSF CRUD generator, JPA (Java Persistence API)
• Creazione di webservices RESTful a partire da tabelle database o entità JPA
• Drag and drop di servizi SaaS in file PHP
• Migliorato l’editor SQL Editor: autocompletamento del codice, salvataggio query
• Migliorata l’importazione e sincronizzazione di progetti Eclipse
• Salvataggio e deploy delle applicazioni automatico

Groovy and Grails

• Sviluppo di applicazioni in Groovy puro o inclusione di classi e script Groovy in progetti Java
• Editor Groovy: autompletamento del codice, evidenziazione keywords
• Support per applicazioni web Grails
• Apertura e gestione di applicazioni Grails esistenti senza creazione di Metadati di progetto

Ruby e Rails

• Nuova interfaccia per lanciare i test e mostrare i risultati
• Miglioramenti Rake: Rake Runner e pre-generazione del file Rake
• Debugger: Breakpoints condizionali e “Catchpoints”
• Progetti Ruby accettano opzioini JVM da riga di comando

GlassFish v3

• Modulare e basato su architettura OSGi
• Velocizzata la procedura di avvio e quella di deploy delle applicazioni
• Supporto per scripting

C/C++

• Migliorato l’autocompletamento del codice, evidenziazione degli errori e delle keywords
• Grafico delle chiamate e finestra della memoria usata/allocata
• Sviluppo remoto
• Pacchettizzazione delle applicazioni come tar, zip o SVR4

Java ME

• Nuovo wizard che permette di aggiungere componenti personalizzati alla Palette
• Nuovo componente SVG UI
• Nuovo componente Data Binding personalizzato
• Aggiornato il tool ProGuard alla versione 4.2 e il framework di test JMUnit alla versione 1.1.0

Java SE

• possibilità di debuggare applicazioni Java Multi-thread
• Java Swing GUI Builder: Editor TreeModel per JTrees
• Autocompilazione e salvataggio
• Migliorato il supporto per l’importazione e sincronizzazione di progetti Eclipse

[Fonte: http://www.geekissimo.com]

Se c’è qualcuno che non adora navigare per il web con un piacevole sottofondo musicale alzi la mano. Poche mani vedo. Beh, in effetti è un comfort da cui non vorremo mai separarci e quando lo facciamo, a malincuore, è solo perché, magari, dobbiamo anche studiare quello che stiamo visualizzando a video. Assodato che non stiamo studiando e vogliamo solo ascoltare musica, la scocciatura maggiore è dover passare ogni volta che vogliamo cambiare canzone dal browser, al player e poi nuovamente al browser. Se non abbiamo una tastiera in grado di controllare i comandi del nostro player audio non abbiamo tante scelte e la noiosa operazione di passare da una finestra all’altra sembrerebbe inevitabile. Da un po’ di tempo, però, abbiamo la possibilità di aggiungere i comandi di esecuzione (play, pause, next …) direttamente nella barra di stato del nostro browser, ma, ammesso che la barra di stato non sia nascosta, si tratta di centrare col puntatore del mouse dei bottoni non più larghi di 10 pixel. Scomodo, non trovate? Useremo queste, seppur irrisorie, scusanti per implementare un meccanismo che ci permetta di gestire il nostro player usando soltanto dei comandi testuali (evitando di conseguenza di utilizzare il mouse).

FoxyTunes

FoxyTunes è un plugin che permette di controllare la nostra libreria musicale direttamente dal nostro browser preferito. E’ disponibile sia per Internet Explorer che per Mozilla FireFox. Per quest’ultimo l’installazione è semplicissima ed immediata e basta cliccare qui per avviarla. Una volta comlpetata l’installazione, dobbiamo riavviare il browser, alla riapertura, potremo notare che nella barra di stato sono stati aggiunti i comandi per gestire il player (qui troviamo una lista di tutti i player supportati). Abbiamo anche un tasto molto utile che ci condurrà a FoxyTunes Planet, un progetto FoxyTunes acquisito poi da Yahoo. Cliccando sul tasto Planet nel nostro browser verremo portati ad una pagina dove otterremo informazioni riguardo la canzone, l’artista, l’album in cui è presente quella canzone, video e tanto, tanto altro. Questa è la pagina che otterremmo se cliccassimo il tasto FoxyTunes Planet mentre ascoltiamo Rock the Casbah dei Clash. Durante la stesura di questo articolo è stata utilizziata la versione 3.0.4.1 su browser Mozilla FireFox versione 3.0.1.

La barra dei comandi di FoxyTunes.

Ubiquity

Aza Raskin, figlio del più noto Jef Raskin, non è soddisfatto di come al giorno d’oggi si condividono le informazioni nel web. Se qualcuno di noi volesse invitare un amico a pranzo in un ristorante, premurandosi di spiegare come raggiungere il locale allegando anche una recensione per tranquillizzarlo sulla qualità del cibo dovrebbe (nel proprio browser): aprire una tab per l’account mail, aprire una tab per cercare la mappa per le indicazioni, aprire una tab per trovare la recensione del ristorante e infine assemblare i link ottenuti nella stessa mail e inviarla. Abbastanza dispersivo, non ha tutti i torti. Per non parlare se ci trovassimo a compiere tale operazione su dispositivi palmari. Più naturale sarebbe spiegare in linguaggio umano quello che c’è da fare e lasciar compiere a qualcun’altro il lavoro noioso per noi. Questo qualcun’altro, potrebbe essere proprio Ubiquity (installa estensione). Supponiamo che, ad esempio, il ristorante si trovi a Roma, in Via dei Fori Imperiali 34. In gMail (o qualunque altra webMail con una Rich Text Area) creiamo una nuova mail, puntiamo il cursore nell’area dove va scritto il testo, a questo punto premiamo ALT+SPAZIO sulla tastiera, nella finestra che si aprirà scriveremo map Rome Via dei fori imperiali 34 una nuova mappa apparirà, ci basterà cliccare “Insert map in page” ed il gioco è fatto. Quello che segue è un video dimostrativo, in inglese, realizzato dallo stesso Aza Raskin:

Sfruttiamo i due plugin

Ora che abbiamo accennato ai due strumenti principali è venuto il momento di spiegare come farli comunicare tra loro. L’idea di base è stata quella di creare un comando Ubiquity che accetti un parametro, l’esecuzione di tale comando, combinata al parametro, esegue una specifica funzione di FoxyTunes. I comandi vanno scritti in Javascript/JQuery rispettando le convenzioni stabilite da Ubiquity e sono molto semplici da realizzare. Il plugin Ubiquity ci fornisce una pagina molto utile, raggiungibile scrivendo nella barra degli indirizzi del browser about:ubiquity. Tramite questa pagina possiamo vedere varie informazioni, come la versione, verificare la presenza di aggiornamenti, cambiare la combinazione di accesso (ovvero l’ALT+INVIO citato prima), oppure, la cosa che a noi interessa di più, accedere all’editor dei comandi, dove finalmente possiamo iniziare la programmazione del comando.

// version: 0.1
// released: 13/09/2008
CmdUtils.CreateCommand({
name: "foxy-tunes",
takes: {"play|pause|stop|next|prev": noun_arb_text},
description: "",
homepage: "http://mariano.altervista.org/wordpress",
author: { name: "Mariano Calandra", email: "mariano.calandra@altervista.org"},
help: "foxy-tunes command must be followed from one of these actions: play, pause, stop, next, prev.",

preview: function( pblock, param ) {
if (param.text  == "play")
pblock.innerHTML = "Play song";
else if (param.text  == "pause")
pblock.innerHTML = "Pause song";
else if (param.text  == "stop")
pblock.innerHTML = "Stop music";
else if (param.text  == "next")
pblock.innerHTML = "Play the next song";
else if (param.text  == "prev")
pblock.innerHTML = "Play the previous song";
else
pblock.innerHTML = "Uncorrect or empty action! Choice between: play, pause, stop, next, prev.";
},

execute: function(param) {
if (param.text  == "play")
window.foxytunesDispatchPlayerCommand('Play', true);
else if (param.text  == "pause")
window.foxytunesDispatchPlayerCommand('Pause')
else if (param.text  == "stop")
window.foxytunesDispatchPlayerCommand('Stop')
else if (param.text  == "next")
window.foxytunesDispatchPlayerCommand('Next', true)
else if (param.text  == "prev")
window.foxytunesDispatchPlayerCommand('Previous', true)
else
displayMessage( "Uncorrect or empty action! Choice between: play, pause, stop, next, prev.");
}
})

Il nostro codice Ubiquity è stato racchiuso tra CmdUtils.CreateCommand({ codice }), per questo non ci sono molte spiegazioni in quanto è l’unico modo per creare comandi degni di esser chiamati tali. Segue una lista di attributi abbastanza autoesplicativi circa le informazioni da dare all’utente finale. Degne di attenzione sono invece la funzione di preview e di execute. La prima, preview, gestisce il comportamento che deve avere Ubiquity man mano che digitiamo i nostri comandi. La funzione accetta due parametri, pblock e param, il primo rappresenta la parte inferiore del nostro pannello dei comandi Ubiquity (ovvero la parte viola nella figura in basso), il secondo rappresenta quello che scriviamo dopo il comando (il nostro parametro). Se ad esempio scrivessi foxy-tunes ciao allora param varrebbe ciao. All’interno della funzione preview una serie di if controllano i parametri che vengono inseriti, se il parametro esiste spiega in pblock cosa fa quel comando, altrimenti, mostra l’errore e comunica quali sono i parametri accettati. Chi è abituato alla programmazione web dinamica non può non aver notato la presenza del metodo innerHTML associato all’elemento pblock, chi non conosce questo metodo trova una breve spiegazione qui.

Il prompt dei comandi

Premessa: Ubiquity è un progetto sperimentale e nei prossimi tempi potrebbe subire migliorie sostanziali che comporteranno notevoli cambiamenti, il listato di codice precedente è etichettato con versione e data, in modo da render noti quanto più possibile i cambiamenti.La funzione execute invece si occupa di gestire il comportamento del comando immediatamente dopo la pressione del tasto Invio. Prende in ingresso un parametro, param, che rappresenta il parametro passato al comando al momento dell’invio. Una serie di if controllano il parametro fornito, se il parametro è corretto allora viene eseguita la relativa funzione del plugin foxy-tunes. Ad esempio, se il parametro è play, verrà eseguita la funzione foxytunesDispatchPlayerCommand('Play', true). Se viene inviato un parametro non corretto, una popup avvertirà la non correttezza del parametro. Gli utenti Windows visualizzeranno tale avviso vicino l’orologio, in Mac OS X bisogna installare il gestore di richieste Growl.

Rendilo disponibile a tutti

Ora che il nostro comando è funzionante e (si spera) funzionale possiamo pensare di condividerlo con tutto il resto del mondo, e permettere di installarlo senza troppe complicazioni. La prima cosa da fare è salvare il comando in un file Javascript, mioComando.js per esempio. Bisognerà creare poi una pagina HTML e tra i tag head aggiungeremo:

<link rel="commands" href="http://percorso" name="Titolo" />

L’attributo rel non va modificato. Quando un utente con Ubiquity visualizzerà questa pagina gli verrà chiesto se vuole effettuare la sottoscrizione del comando. Se l’utente accetta, il comando farà parte della sua lista comandi Ubiquity. Non mi resta quindi che augurarvi buon divertimento e segnalarvi la wiki di Ubiquity.

Spesso capita di digitare in maniera errata una chiave di ricerca e vedersela correggere non appena clicchiamo il tasto ‘Invio’. Cosa succede? Come può un computer, nella maggior parte dei casi, capire cosa volevamo veramente scrivere? La risposta, abbastanza diretta, è: distanza di Levenshtein (o se lo trovate troppo complicato da pronunciare/scrivere, distanza di edit). Considerate due stringhe sorgente e destinazione, la distanza di Levenshtein è il numero di operazioni elementari necessarie per trasformare la stringa sorgente in quella di destinazione. Essa definisce tre operazioni elementari: i) la cancellazione di un carattere; ii) la sostituzione di un carattere; iii) l’inserimento di un nuovo carattere. Due stringhe uguali hanno distanza di Levenshtein pari a 0.

L’algoritmo

Considerando s come la lunghezza della stringa sorgente e d come la lunghezza della stringa destinazione implementeremo un algoritmo che faccia uso di una matrice (s + 1) * (d + 1). In colonna scriveremo la stringa sorgente, come riga inseriremo invece la stringa di destinazione. In ogni cella della matrice è rappresentata la distanza che intercorre tra una porzione di stringa sorgente e una porzione di stringa destinazione. Nell’angolo in basso a destra le porzioni di stringa sono complete, quindi, il valore che vi è rappresentato è l’effettiva distanza tra la stringa sorgente e quella di destinazione. Un esempio: supponiamo che io voglia conoscere la distanza tra il mio vero nome mariano e una stringa ottenuta per errata digitazione, supponiamo marinao (errore comune).

La matrice sopra rappresenta il calcolo che svolge l’algoritmo per arrivare al risultato finale, ossia la distanza contenuta nella cella in basso a destra, tutte le altre celle sono intermedie. Per alcune celle, (quelle tratteggiate in basso), è stata aggiunta una breve spiegazione su come è stata calcolata la distanza, basterà tenere il puntatore fermo per qualche secondo e leggerne l’etichetta. In questa pagina c’è un’applet Java che prende in ingresso una stringa di destinazione e una di origine e ci mostra la matrice, risultante da provare. Ovviamente quest’algoritmo si trova in numerose versioni, sia per quello che riguarda il linguaggio in cui è stato sviluppato sia per il modo in cui è stato sviluppato. Il seguente algoritmo, infatti, non è il più efficiente nel calcolo della distanza di Levenshtein ma in compenso ci permette di avere un codice più autoesplicativo. Per coloro che sviluppano in PHP la funzione per il calcolo della distanza è una built-in del linguaggio [link]. La versione di questo articolo è in linguaggio Java.

public class Distance {
/** Questo metodo calcola il minimo tra tre numeri interi*/
private int getMinimo(int a, int b, int c) {
int min;

// imposto il minimo uguale ad a
min = a;
// se il parametro b è minore del minimo
if (b < min) {
// il nuovo minimo sarà il parametro b
min = b;
}

// se il parametro c è minore del minimo
if (c < min) {
// il nuovo minimo sarà il parametro c
min = c;
}
// ritorno il minimo (min)
return min;
}

/** Funzione per il calcolo effettivo della distanza di Levenshtein*/
private int getDistanza(String s, String t) {
int d[][];     // matrice
int n;         // lunghezza di s
int m;         // lunghezza di t
int i;         // iterazioni su s
int j;         // iterazioni su t
char s_i;      // i-esimo carattere di s
char t_j;      // j-esimo carattere di t
int costo;

n = s.length(); // n conterrà il num di caratteri di s
m = t.length(); // m conterrà il num di caratteri di t
// se la stringa sorgente è vuota
if (n == 0) {
// la distanza è il num di chr della dest.
return m;
}
// se la stringa destinazione è vuota
if (m == 0) {
// la distanza è il num di chr della sorg.
return n;
}
// creo la matrice (n+1)*(m+1)
d = new int[n + 1][m + 1];

// la prima riga della mat. conterrà le distanze da 0 a n
// la distanza 1 è associata al primo chr della stringa, 0 al vuoto
// Nel caso del nostro esempio:
// 0 1 2 3 4 5 6 7
// - M A R I A N O
for (i = 0; i <= n; i++) {
d[i][0] = i;
}

// la prima colonna della mat. conterrà le distanze da 0 a m
// la distanza 1 è associato al primo chr della stringa, 0 al vuoto
// Nel caso del nostro esempio:
// - 0
// M 1
// A 2
// R 3
// I 4
// N 5
// A 6
// O 7
for (j = 0; j <= m; j++) {
d[0][j] = j;
}

// esamino ogni carattere di s (i da 1 a n)
for (i = 1; i <= n; i++) {
s_i = s.charAt(i - 1);

// Esamino ogni carattere di t (j da 1 a m)
for (j = 1; j <= m; j++) {
t_j = t.charAt(j - 1);

// Se l'i-esimo elemento di s
// è uguale al j-esimo elemento di t
if (s_i == t_j) {
// il costo è 0
costo = 0;
} else { // altrimenti
// il costo è 1
costo = 1;
}

// imposto la cella d[i][j] scegliendo il valore minimo tra:
//   - la cella immediatamente superiore + 1
//   - la cella immediatamente a sinistra + 1
//   - la cella diagonalmente in alto a sinistra più il costo
d[i][j] = getMinimo(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + costo);
}
}

// una volta completate tutte le iterazioni la cella
// d[n][m] contiene la distanza finale tra la stringa
// sorgente e quella di destianzione
return d[n][m];
}
}

Eseguendo come da esempio il metodo getDistanza() e passando come parametri le stringhe mariano e marinao avremo come risultato la distanza di Levenshtein tra le due stringhe, ossia: 2. Il lettore più ansioso di arrivare alla soluzione si starà chiedendo cosa farsene di questo numero, d’altronde Google (ad esempio) accetta una stringa e se questa non esiste tenta di fornire la stringa corretta, fin qui invece la nostra funzione necessita come argomenti sia della stringa corretta che di quella errata. Che senso ha? Bene! Il solito lettore ansioso sappia di non aver perso tempo fino ad ora. Siamo infatti arrivati solo a metà dell’articolo.

Come sfruttare la distanza

Ora che abbiamo un metodo in grado di fornirci la distanza tra due stringhe possiamo passare alla parte più interessante, ovvero, come “indovinare” la parola che avrebbe voluto scrivere in realtà l’utente. L’idea di base è concettualmente molto semplice, restringiamo il campo alla ricerca in un array in modo da non essere troppo dispersivi. Vogliamo verificare se nell’array dizionario è presente la parola x. Se tale parola non è presente allora si cerca in dizionario qual’è la parola che più somiglia alla parola x, ovvero, quella con la minore distanza di Levenshtein rispetto a x. In pratica calcoleremo la distanza di Levenshtein tra x ed ogni parola di dizionario, la parola con distanza minore potrebbe essere quella che l’utente cercava. La classe precedente sarà quindi completata con l’aggiunta di un nuovo metodo.

/** Calcolo una parola alt alternativa alla parola input s*/
public String getAlternativa(String s, String d[]) {
int i,             // iteratore ciclo for
min = 100;     // iniziallizzo il minimo a 100
int rit;           // distanza di hamming
String alt = "";   // stringa da ritornare

// per ogni elemento dell'array d
for (i = 0; i < d.length; i++) {
// calcolo della distanza tra s e l'i-esimo elemento d
rit = getDistanza(s, d[i]);
// se la distanza è minore del minimo
if (rit < min) {
// la distanza rit sarà il nuovo minimo
min = rit;
// e l'i-esimo elemento di d sarà l'alternativa
alt = d[i];
}
}
// ritorno l'alternativa
return alt;
}

Ora abbiamo la nostra classe Distance che ci fornisce tutti i mezzi per realizzare il nostro scopo, basterà creare un’istanza di tale classe quando serve per poter trovare un alternativa valida ad una parola digitata in maniera errata. L’approccio scelto utilizza un dizionario di parole al cui interno sono memorizzate le parole esatte. Ovviamente quanto più è grande il dizionario maggiore sarà la precisione con cui l’algoritmo “indovinerà” la parola esatta e di conseguenza maggiore sarà il carico. che la macchina dovrà sopportare Questo che segue è l’esempio di una classe che implementa la distanza di Levenshtein per trovare la giusta alternativa alla parola marinao, avendo un dizionario limitato a solo 3 parole:

public class Main {
public static void main(String[] args) {
String parole[];

parole = new String[3];
parole[0] = "mariano";
parole[1] = "marziano";
parole[2] = "martino";

Distance d = new Distance();
System.out.println("Forse cercavi: "+d.getAlternativa("marinao", parole));
// Forse cercavi: mariano
}
}

Limiti matematici

L’algoritmo per la distanza di Levenshtein è caratterizzato da dei limiti strettamente matematici e sono i seguenti:

• il limite superiore è pari alla lunghezza della stringa più lunga;
• il limite inferiore è pari alla differenza fra le lunghezze delle due stringhe;
• se le stringhe sono identiche la distanza è 0 (e la distanza di Levenshtein non supera la distanza di Hamming)

Conclusioni

Sebbene funzionale, tale algoritmo, se usato con grandi moli di dati mostrerebbe subito i suoi limiti. E’ possibile ridurre l’occupazione di memoria del precendente algoritmo osservando che ad ogni passo dell’iterazione è sufficiente mantenere due righe della matrice, quella corrente e qualle precedente. Usando questo accorgimento è possibile ridurre l’occupazione di memoria da O(mn) a O(m). Inoltre potrebbe essere interessante relegare al database il calcolo della distanza, visto che sarebbe molto più conveniente mantenere il nostro dizionario di parole direttamente in una base di dati, insomma, ci sono ancora sperimentazioni da fare. C’è da ricordare che l’algoritmo è case-sensitive per cui la stringa “Mariano” è diversa da “mariano”, quindi prima di un confronto sarebbe opportuno portare le stringhe completamente toUpperCase() o toLowerCase(). Un buon tool di supporto per comprendere bene come funziona il calcolo della distanza di Levenshtein lo trovate qui.

public class StaticDemo
{
   // Questo è un membro non-static
   public String non_static = "pippo";

   // Questo è un metodo static
   public static void main (String args[])
   {
      /* Qui provo a leggere il valore di una variabile
      non-static da un metodo static (main) */
      System.out.println ("Valore:" + non_static );
   }
}

Errore di compilazione! In questo caso, infatti, sto cercando di accedere ad un membro non-static (come l’attributo non_static) della classe da un metodo static (come il main), per risolvere devo creare un’istanza della classe. Ecco come fare:

public class StaticDemo
{
   // Questo è un membro non-static
   public String non_static = "pippo";

   // Questo è un metodo static
   public static void main (String args[])
   {
      // Qui creo un'istanza della classe
      StaticDemo demo = new StaticDemo();

      /* Ora grazie alla notazione dotted posso accedere
      alla variabile non statica */
      System.out.println ("Valore:" + demo.non_static );
   }
}

Tutto qui! Sebbene molto frequente quest’errore non è insidioso in quanto viene immediatamente rilevato in fase di compilazione:

non-static variable [identificativo] cannot be referenced from a static context