Honoring the greatest driver

E’ da poco iniziato il campionato di Formula 1 e come ogni anno sono state introdotte nuove regole per cercare di aumentare lo spettacolo. Anche se, secondo me, lo spettacolo non è migliorato.

Girovagando per la rete ho trovato il link che riporto poco sotto, un video sul quello che secondo me è il più grande pilota di Formula 1 di tutti i tempi: Ayrton Senna.

Dateci un’occhiata. Ne vale la pena.

Non me ne vogliano i tifosi di Hamilton, ma il casco Verde e Oro lo merita solo Ayrton.

NetBeans 6.9 Milestone 1 – Finalmente ho deciso di provarla

Finalmente, per alcuni, ho deciso di “farmi del male”, di tornare sul software instabile. Ho installato sul mio pc la prima milestone dell’ambiente di sviluppo NetBeans 6.9.
Oltre a nuove funzionalità, che non si sa se arriveranno fino alla fine dello sviluppo, è da sottolineare la presenza di molti nuovi suggerimenti che l’ambiente propone durante l’operazione di scrittura del codice.

La prima impressione è molto buona, anche se sembra consumare un pò troppa memoria..
Adesso ritorno a giocare con il nuovo ambiente. Vi terrò aggiornati!

Happy coding!

Come avere un JList automaticamente ordinato

Eccoci qua, quante volte è successo di diventare scemi per ordinare il contenuto di una JList? A me parecchie volte.

Le prime volte avevo sfruttato dei barbatrucchi a dir poco orrendi e poco performanti am adesso mi sono deciso a sistemare un pò le cose. Pubblico per tutti una prima versione di un modello da applicare ad un componente JList in modo che il contenuto sia automaticamente ordinato in modo crescente.

Spero che possa aiutare.

Se trovate degli errori o un modo per migliorare questo modello vi prego di non esitare a inviarmi le modifiche. Nel caso in cui vorreste utilizzare questo modello vi chiedo solo di lasciaee un riferimento a me e questo blog nel sorgente.

L’unico requisito minimo della piattaforma è la versione 5, in modo da poter sfruttare i Generics.

import java.util.Collection;
import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;
import javax.swing.AbstractListModel;
import software.myit.gestionale.database.bin.models.DataModelI;

/**
 * Implementa un modello dei dati per una lista ordinata
 *
 * @author Marco Capoferri
 * @version 0.1
 */
public class SortedListModel<T extends Comparable<T>> extends AbstractListModel implements DataModelI<T> {
    private SortedSet<T> containedData;

    public SortedListModel() {
        this(new TreeSet<T>());
    }

    public SortedListModel(SortedSet<T> containedData) {
        this.containedData = containedData;
    }

    @Override
    public boolean addData(T value) {
        boolean esito = containedData.add(value);
        if (esito) {
            fireContentsChanged(this, 0, getSize());
        }
        return esito;
    }

    @Override
    public boolean addData(Collection<T> values) {
        boolean esito = containedData.addAll(values);
        if (esito) {
            fireContentsChanged(this, 0, getSize());
        }
        return esito;
    }

    @Override
    public void clear() {
        containedData.clear();
        fireContentsChanged(this, 0, 0);
    }

    @Override
    public T getDataAt(int i) {
        return (T) containedData.toArray()[i];
    }

    @Override
    public T getElementAt(int i) {
        return (T) containedData.toArray()[i];
    }

    @Override
    public int getSize() {
        return containedData.size();
    }

    @Override
    public Iterator<T> iterator() {
        return containedData.iterator();
    }

    @Override
    public boolean removeData(T value) {
        boolean esito = containedData.remove(value);
        if (esito) {
            fireContentsChanged(this, 0, getSize());
        }
        return esito;
    }

    @Override
    public boolean removeData(Collection<T> values) {
        boolean esito = containedData.removeAll(values);
        if (esito) {
            fireContentsChanged(this, 0, getSize());
        }
        return esito;
    }
}

Mentre invece questa interfaccia serve per generalizzare il modello, nel caso in cui lo si voglia adattare anche per i modelli di tabelle e altri componenti grafici.

public interface DataModelI<T extends Comparable<T>> extends Iterable<T> {
    /**
     * Aggiunge l'oggetto fornito al contenitore, se non già presente
     * 
     * @param value Oggetto da aggiungere al contenitore
     * @return Esito dell'operazione di aggiunta
     */
    public boolean addData(T value);
    /**
     * Aggiunge la collezione di oggetti fornita al contenitore, se non già presente
     *
     * @param value colelzione di oggetti da aggiungere al contenitore
     * @return Esito dell'operazione di aggiunta
     */
    public boolean addData(Collection<T> values);
    /**
     * Svuota il contenitore
     */
    public void clear();

    /**
     * Restituisce l'elemento presente nela posizione indicata
     *
     * @param i Posizione dell'elemento da estrarre
     * @return Oggetto presente nella posiione indicata
     */
    public T getDataAt(int i);

    /**
     * Rimuove l'oggetto fornito dal contenitore, se presente
     *
     * @param value Oggetto da rimuovere dal contenitore
     * @return Esito dell'operazione di rimozione
     */
    public boolean removeData(T value);
    /**
     * Rimuove la collezione di oggetti forniti dal contenitore, se presenti
     *
     * @param values Collezione di oggetti da rimuovere dal contenitore
     * @return Esito dell'operazione di rimozione
     */
    public boolean removeData(Collection<T> values);
}

Riducendo la possibilità di errore con gli Enum in Java (Parte 1)

Nle linguaggio Java, a partire dalla versione 1.5, sono stati introdotti gli enumeratori, cioè degli oggetti particolari che funzionano come degli insiemi immutabili.

Fino alla prittaforma 1.4.2 il programmatore era costretto ad arginare questa mancanza utilizzando delle costanti statiche di vario tipo, solitamente int e char per non pesare troppo sulla memoria. La tecnica delle costanti è alla base degli enum e di per se non è sbagliata am in alcune circostanze è “rischiosa” poichè può indurre ad errori.

Gli enum sono stati creati con l’intenzione di rendere più sicura e maggiormente mantenibile questa conosciuta ed ormai collaudata tecnica, come già detto questi non sono altro che insiemi finiti di costanti, ai quali non è necessario attribuire un valore poichè già essi corrispondono per loro natura ad un valore differente dalgi altri membri dell’insieme.

Consideriamo il seguente codice per creare un enumeratore che modella un insieme di 5 elementi.

public enum ProvaEnum {
    ELEMENTO_1, ELEMENTO_2, ELEMENTO_3, ELEMENTO_4, ELEMENTO_5;
}

E consideriamo inoltre i seguenti metodi

public void stampaElementoEnumeratore(ProvaEnum valore) {
    System.out.println("Il valore dell'elemento fornito è: " + valore);
}

public void stampaElementiEnumeratore() {
    for (ProvaEnum value : ProvaEnum.values()) {
        stampaElementoEnumeratore(value);
    }
}

Il primo metodo stampa l’oggetto fornito su standard output ed è in grado di ricevere solament uno dei valori esplicitati nella creazione dell’enumeratore. Il secondo metodo invece ottiene dall’enumeratore l’insieme degli elementi definiti ed invoca su di ognuno di essi il metodo definito poco sopra.

Proviamo a pensare ad un  contesto in cui viene utilizzata ancora la, oramai obsoleta, tecnica delle costanti. Nel toolkit grafico Swing si usa, per questioni di retrocompatibilità, in modo massiccio la vecchia metodologia ed una programmazione errata può portare a degli errori imprevedibili.

Consideriamo il BoxLayout questo può essere disporre i componenti di un pannello affiancandoli in 4 orientamenti: sull’asse X, sull’asse Y, sull’asse X relativo (LINE_AXIS) e rispetto all’asse Y relativo (PAGE_AXIS). Questi orientamenti vengono selezionati fornendo al costruttore un valore numerico; solitamente si è portati ad utilizzare le costanti messe a disposizione dalla classe ma nulla ci vieterebbe di fornire direttamente un valore intero.

Adesso provate a pensare, se fornite un valore intero che non corrisponde a nessuna delle 4 costanti cosa succede? Io non ho mai provato e sono convinto che gli ingegneri che hanno progettato il toolkit e gli sviluppatori che lo hanno realizzato hanno previsto questa ipotesi e quindi sicuramente avranno implementatoun meccanismo di controllo per prevenire errori di questo tipo.

Con gli enumeratori non sarebbero necessari questi controlli e quindi si potrebbe scrivere codice più efficiente in fase di runtime dato che i controlli del caso verrebbero svolti in fase di compilazione, quidni una sola volta in tutta la vita dell’applicazione.

Continueremo con la trattazionedegli enumeratori nei prossimi giorni.

Buon divertimento!

Iniziamo a rendere a Cesare quello che è di Cesare…

Ciao a tutti

Ho deciso di iniziare a rendere ad un amico (il buon Iade Gesso) alcune delle cortesie che mi ha fatto, a livello informatico. Una cosa per volta e si fa tutto. O no?

Tempo fa ho iniziato a lavorare con il JDK  7 messo a disposizione dalla allora Sun Microsystems e avevo bisogno di un piccolo adattamento di un paio di classi da impiegare in un progetto. Potevo realizzare da me questo adattamento ma, causa la scarsità di tempo, ho chiesto a Iade un piccolo aiuto e lui, pur essendo in pieno periodo di tesi magistrale, accettò di buon grado.

Il suo aiuto consisteva nell’adattare alcune classi, scritte originariamente da Kirill Grouchnikov, che implementano un pannello in grado di visualizzare l’albero delle directory e dei file relative ad una determinata posizione del filesystem utilizzando le ultimissime API NIO2.

Nella speranza che questo piccolo adattamento possa essere utile a qualcuno, qua potrete trovare la versione modificata del pannello.

Con questo cosa voglio dire? Semplicemente Grazie Iade!

Inizia la mia avventura con i blog, nasce “Blog in progress…”

Ciao a tutti!

Volevo inaugurare il mio blog inserendo qualcosa di carino ma ho troppe cose che mi frullano per la testa e non so con cosa cominciare.. -.-

Innanzitutto voglio spiegare il semplice motivo di questo Blog. Mi piacerebbe avere uno scambio di opinioni e di cultura informatica e non solo con chiunque voglia fare 2 parole. Inoltre spero che gli articoli, tecnici e non, che ho intenzione di pubblicare possano aiutare chi vaga per la rete in cerca di una risposta su di un determinato argomento o anche solo far fare una risata a chi vorrà seguire la storia di questo blog.

Un grazie di cuore in anticipo a tutti coloro che mi seguiranno in questa avventura.

Ciao Marco