Eclipse Oxygen

Dal mese scorso è disponibile Eclipse Oxygen, la nuova versione del popolare IDE tuttofare.
Questa versione ha diverse migliorie sia alla parte di sviluppo Java che alla parte di gestione git. Una cosa che noto è che sempre di piu' gli sviluppatori pongono l'attenzione verso scorciatoie da tastiera per aiutare e velocizzare l'interazione con l'ambiente, come ad esempio CTRL-e per ciclare fra i tab degli editor o ALT-c per entrare nello staging git.

Eclipse Survey

C'è una survey "What is Eclipse?" disponibile per la compilazione anonima.
Il questionario, composto da 16 domande, non è basato su aspetti tecnologici spinti, quanto sull'utilizzo stesso dei progetti
delle tecnologie alla base di Eclipse.
Penso valga la pena spendere qualche minuto per la compilazione.

Eclipse 4 è migliore di Eclipse 3?

Per quelli che, come me, ritengo che Eclipse 4 sia stato un pessimo IDE (e lo sia ancora, mannaggia!), un interessante articolo che spiega dove si era giunti con la versione 3.8 e dove si è tornati con le varie versioni 4 che si sono dovute rilasciare per fornire un IDE nuovamente degno del marchio di Eclipse.

Spero vivamente che le prossime versioni pongano fine a tutti i micro-problemi che hanno decisamente fatto scendere Eclipse nella classifica dei miei ambienti preferiti...

Eclipse Neon, Tomcat 7 e il nome del server non editabile...

Sono inciampato in un piccolo bug di Eclipse Neon 1: ero impossibilitato a creare qualunque server Tomcat 7 perchè non mi era possibile inserire il nome del server, come invece avveniva correttamente per le altre versioni di Tomcat (sia inferiori che maggiori).

La soluzione, nel mio caso, è stata quella di rimuovere i due file

org.eclipse.jst.server.tomcat.core.prefs

org.eclipse.wst.server.core.prefs

dalla directory .metadata/.plugins/org.eclipse.core.runtime/.settings dentro al workspace.

Ovviamente tutto fatto ad Eclipse spento (e con backup di tali file).

Eclipse: un bell'esempio OpenSource da oltre 15 anni!

Eclipse è un pezzo fondamentale della storia di qualunque programmatore, non importa il linguaggio o il sistema operativo, non conosco nessun developer che non abbia mai provato almeno una volte questo IDE.

Certo, IDE è riduttivo, Eclipse segue la filosofia di tanti progetti ambiziosi (es. Emacs) di creare veri e propri ecosistemi estendibili da parte dell'utente (sviluppatore) e che possono essere utilizzati come base per applicazioni e sistemi complessi.

Io stesso ho usato nel tempo Eclipse come ambiente di sviluppo e piattaforma per la costruzione di alcune applicazioni.

A parte la mia storia personale con questo strumento, che forse è diventato un po' troppo complesso ed enorme, Eclipse festeggia un importante ricorrenza: sono ormai 15 anni che il codice sorgente è diventato di pubblico dominio.

In un periodo nel quale l'OpenSource sembra un po' "passato di moda" questo è un buon promemoria di come una politica Open Source sia tutt'altro che sorpassata o sorpassabile.

My story about using Eclipse

I started using Eclipse as my first Java IDE back in 2004.

I had always written code in Java, since version 1, but back in those days I was using some very simple editing (even the Microsoft Edit, it was even before I started using Emacs!) or some less expensive (in term of resources) IDEs.

My switch to a "real" IDE was during the fourth year of University, when I started using Borland. I remember the IDE was around 80 MB in size and required almost a minute to start on my Pentium IV. Nevertheless it was simple and to the point: it allowed me to develop in Java having syntax highlight, Javadoc inspection, project management and some other feature.

Ok, I have to say it was much more than I needed, since I was working on one or two projects at the same time back in those days. Morever, I was totally unaware of code versioning, and in fact I had developed my own way of doing incremental backups, but that's another story.

While approaching my master thesis, that of course had to be based on Java (not because of choice of mine), I started evaluating some other Java IDE. At that time the Forte For Java was a really famous piece of code, but it was a little hungry on resources and required almost two minutes to start up on my Celeron 700 MHz with 192 MB of RAM. Moreover, while the start up time was not such a big deal for me, having to work for a lot of hours without turning off the computer, the program itself was pretty much unusable with menus half-empty, rendering delays and freezes.

I tried then the Emacs extension for Java, but at that time I was a young Emacs users and the whole JDEE was too much complex for either my fingers and brain.

Having spent a couple of weeks searching for a product, I switched back to the Borland Java IDE, something I already know quite well and that allowed me to be productive from day one.

In the following years I experimented a lot with other two emerging products: IBM Eclipse and Netbeans IDE. However I was not working as a Java developer, or better, Java was not my main language after the university, and therefore I did not spent a lot of time using them for real projects.

In 2004 there was a shift: at the Principle and Practice of Programming Java (PPPJ) conference in Kilkenny I met Vivek Sarkar, an IBM fellow that shown us the magic power of Eclipse (and of Jikes RVM for what it matters). At that time there was Eclipse 2 (if my memory serves me well 2.2) and the main feature that astonished us was the "refactoring" capabilities of Eclipse.

Once I was back home I installed Eclipse and switched definitely to such environment, letting Emacs for quick-and-dirt editing.

Several year later, at the time of version 3, I got back to a Java-based job and developed an application with the Rich Client Platform (RCP), so I used Eclipse to develop another Eclipse application (a kind of recursion that computer scientist seems to appreciate very well).

Then I had to manage a PHP codebase, and did it with Eclipse too even if, I have to admit, the support to such language was not mature enough and the editor had some lag.

Today I use Eclipse on a regular day-by-day basis mainly for web development, and mainly for Java because I use Emacs for all the rest.

La Nebula che avanza

E' passato molto tempo da quando iusavo Nebula, un framework di widget SWT estesi complessi atti a creare interfacce grafiche ricche e complete. Vedo che il progetto è andato avanti con determinazione, creando nuovi widget di transizione e tabelle che, a prima vista, sono ideali per programmi di interfacciamento con la borsa o mercati dinamici. Ahimé alcuni dei widget che avrei sempre voluto usare, come il CollapsibleButton sono ancora in fase di incubazione.

Sono convinto che il progetto Nebula sia molto importante, anche se probabilmente ha risentito dell'avvento delle interfacce web che hanno, in parte, semplificato e ridotto le richieste ai programmi desktop.

Eclipse Day Florence 2013

Ho partecipato alla seconda edizione dell'Eclipse Day Firenze (EDF 2013), organizzata da RCP-Vision presso il centro congressi di Firenze una settimana fa. Devo dire che questa edizione mi è piaciuta anche piu' della precedente: in particolare molte presentazioni hanno incluso delle demo live from scratch, che hanno permesso al pubblico di meglio comprendere come la tecnologia Eclipse e l'intero ecosistema si sia evoluto.

La conferenza ha avuto un tenore molto serio, forse fin troppo per i miei guisti, ma nulla da eccepire sull'organizzazione e sul catering, sempre di alto livello, nonché sul centro congressi che è sempre bello (sarà perché comunque adoro la Toscana in generale e quindi mi appare sempre tutto molto bello).

Devo comunque notare che mi appare sempre piu' evidente come l'ecosistema Eclipse si sia evoluto per sopperire alle carenze proprie del linguaggio Java, e ora sia possibile fare instrumenting con pseudo linguaggi che prendono caratteristiche di altri linguaggi, come l'operator overloading che gli ingegneri Java hanno tanto disgustato...

My story about using IBM Eclipse

For one reason or the other, my jobs always required the development of Java applications. I was used to work with Borland JBuilder, and the main reasons were it was simple but powerful and did not waste  megabytes or RAM making me wait more than 30 seconds to start and be fully functional. Nevertheless, it had some limitations, and so I was thinking to switch to a more complex and heavy environment, in particular NetBeans.

Then, at the 2002 PPPJ in Kilkenny, I attended the keynote speech of Mr. Vivek Sarkar that was at that time employed at IBM and therefore presented Eclipse 2. After the speech, while having a coffee, I asked what were the differences between Eclipse and NetBeans and why use one instead of the other. The main reason I got was the code refactoring, so once at home I installed Eclipse and tried it on my code base. At glance I did not like it: it was too heavy and complex, with too many functions and windows and tabs and other annoying stuff (I'm a terminal guy...). But the code refactoring was really impressive and I found it really useful.

So I started using Eclipse for my day-to-day development. 

Today it is still my Java default IDE, and I have noticed that a lot of people use it as a kind of fancy editor with autocompletion, without using some of the more interesting features like run configurations and Mylin.

In one of my previous job I had to create a client-server Java application that should have been really fast to run on Microsoft Windows and Apple machines. So I thought it was time for giving a try to SWT, the IBM Java toolkit Eclipse is based on. 

From SWT to Eclipse RCP the jump was fast and great, and therefore I started developing applications using Eclipse RCP v3.

Eclipse Day 2012

Il 4 Maggio 2012 si è svolto, a Firenza, l'Eclipse Day, una conferenza di un giorno interamente dedicata al panorama Eclipse. L'evento, organizzato da RCP Vision, si è rivelato veramente interessante e denso. Devo ammettere che era da tempo che non partecipavo ad una conferenza così interessante!

L'evento si è svolto tutto in lingua inglese, con un servizio di traduzione al volo effettuato da interpreti professionisti. La location, il palazzo congressi, era veramente eccezionale e il catering è stato eccellente. Anche gli speaker che si sono avvicendati sono stati tutti professionali e puntuali, permettendo uno svolgimento dell'evento senza intoppi.

Ho seguito con grande interesse il keynote di Mike Milinkovich che ha parlato di Open Source e di come Eclipse abbracci e contribuisca a questa filosofia. Veramente illuminante il talk del committer Tom Schindl che ha illustrato come funzionerà internamente la nuova piattaforma Eclipse e4 e come la dependency injection permetta la rapida risoluzione di alcuni fastidiosi bug. Molto accattivante anche la presentazione di Ralf Sternberg circa RAP, un altro progetto che mi interessa molto anche se non ho ancora avuto modo di speramentarlo con applicazioni reali. Questi sono anche gli speaker con i quali ho conversato maggiormente durante i vari coffe break e alla conclusione dell'evento, ma tutti gli altri sono stati di pari livello. Gli unici talk che mi hanno un po' deluso sono stati quelli del guru Lars Vogel (autore di innumerevoli tutorials), che seppur di alta qualità tecnica è stato piuttosto noioso, e quello di Silvia Mazzini che ha presentato l'interessante collaborazione Polarsys in un modo per me un po' nebuloso e troppo burocratico. Non mi ha stupito nemmeno il talk circa Microsoft Azure, non tanto perché di casa Microsoft, ma perché ritengo che vendere virtualizzazione a colpi di click senza far preoccupare lo sviluppatore/amministratore dei problemi di balancing e performance sia pura fantasia (ammetto che qui scatta la mia inclinazione da databasista).

Una cosa che ho apprezzato molto è che praticamente ogni speaker ha presentato delle demo live che hanno permesso di verificare sul campo quanto appena esposto così da potersi rendere conto dei tempi effettivi di implementazione di concetti e soluzioni.

Eclipse e il renaming dei getter/setter

Una delle feature che ha maggiormente contraddistinto Eclipse rispetto ad altri IDE è stato il refactoring, introdotto con la versione 2. Nel refactoring, una delle caratteristiche che uso maggiormante nel mio lavoro quotidiano è il rename che consente di modificare il nome di una variabile o metodo andando ad aggiustare automaticamente tutte le occorrenze nel progetto.

Dalla versione 3 di Eclipse il rename non viene piu' fatto tramite una dialog, ma tramite digitazione diretta del nuovo nome in overwrite. Questo ha fatto si che mi scordassi, con il tempo, che Eclipse ha anche la possibilità di aggiustare i nomi dei getter e setter di una variabile. Un collega mi ha ricordato che visualizzando la finestra di dialogo di rename all'atto della rinomina è possibile spuntare i checkbox per rinominare anche i metodi di accesso alla proprietà.

10 anni di eclissi

Il progetto Eclipse compie 10 anni!

Ricordo ancora qualndo venni a conoscenza di questo IDE, alla conferenza Principle and Practice of Programming Java nel 2003. All'epoca quello che faceva spiccare Eclipse rispetto agli altri prodotti era il refactoring; la versione era ancora la 2, e quindi lo schema dei plugin stava prendendo forma ma senza il concetto di OSGi che ha prodotto il vero salto di qualità della piattaforma (almeno a mio avviso).

Io sono diventato utente Eclipse dal 2003, anche se l'uso intensivo dell'IDE l'ho iniziato ad avere nel 2004.

Eclipse & FreeBSD

Ho avuto recentemente dei problemi nell'installazione di Eclipse dall'albero dei ports su un FreeBSD 9 rc-1. Chiedendo aiuto nei forum ufficiali, ho scoperto che Eclipse non è un gran IDE secondo la community FreeBSD. In effetti se ci si pensa, anche la piattaforma RCP fornisce runner nativi per Windows, Linux e OSX, ma non per altri Unix generalizzati.

Eclipse RCP e il suo utilizzo da parte di IBM...

Nell'epoca delle applicazioni Web puo' sembrare strano che si continui ad investire su applicazioni Rich Client. Come sviluppatore Java per me il top delle tecnologie RCP e' Eclipse RCP, e IBM ha attualmente utilizzato la sua ben collaudata piattaforma di sviluppo RCP per la realizzazione della applicazione per la gestione del reparto vendite di IBM stessa. Quando si dice "eat your dog food"!

Dipendenze dei moduli Web in Eclipse Helios

Quando si sviluppa un progetto Web dinamico (Dynamic Web Project) in Eclipse, una funzionalita' molto comoda e' quella che permette di esportare automaticamente assieme alla propria web application una o piu' librerie utente. Questo veniva svolto dal J2EE Module Dependencies, che nelle ultime versioni di Eclipse e' stato sostituito dal piu' scarno Deployment Assembly. Sostanzialmente si tratta di andare nelle proprieta' di progetto e aggiungere, nella finestra di Deployment Assembly, le librerie utente che servono all'esecuzione del progetto.

Eclipse (Equinox): specificare quale JVM usare per eseguire l'ambiente

La configurazione di Eclipse/OSGi avviene tramite un file di proprieta' di avvio, solitamente denominato eclipse.ini (da notare l'orrendo retaggio .ini tipico della configurazione Microsoft Windows!) che contiene una lista di proprieta' lette dal launcher nativo OSGi /Equinoxusato dalla piattaforma Eclipse stessa.
Una opzione molto importante per l'avvio di Eclipse (IDE) e' la virtual machine da utilizzare per eseguire l'IDE stesso. Sembra banale, ma nell'epoca degli aggiornamenti software automatici, e' molto facile perdere il controllo su quale JVM/JDK viene usata per eseguire diverse applicazioni, specialmente se si considera che Eclipse non tiene conto di variabili di ambiente (es. la classica JAVA_HOME). Specificare la JVM da usare per l'avvio di Eclipse (IDE) e' molto semplice: si deve inserire una riga con l'opzione -vm e sulla riga seguente il path completo all'eseguibile java da usare, come ad esempio:

-vm
/sviluppo/java/jdk1.6.0_23/bin/java

Da notare che questa opzione deve essere specificata prima della riga -vmargs, poiche' tutte le righe che seguono l'opzione -vmargs verranno trattate come parametri da passare alla virtual machine stessa. E' anche possibile specificare l'opzione su riga di comando, nel qual caso occorre inserire il path dell'eseguibile fra apici doppi.

Eclipse Visual Editor

Finalmente sono riuscito ad installare il Visual Editor su Eclipse Helios, ma ho dovuto scaricare il pacchetto e installarlo manualmente come fosse un repository locale. Per aprire un file visuale con l'editor è necessario fare click destro sulla risorsa e selezionare Open With -> Visual Editor (al posto di Java Editor). Da notare che nel mio caso (applicazione RCP con viste e editor) l'editor non si comporta bene poiché non riconosce esattamente la vista o l'editor se questo viene creato con variabili "temporanee" (ossia non di istanza). Dovrò lavorare un po' per adattare il mio sistema all'uso del VE.

RCP: tray icon

Una applicazione RCP può facilmente visualizzare una icona integrata nel vassoio di sistema (tray). A tale icona può poi essere associato un menu' contestuale e delle relative azioni.
Per aggiungere una icona tray ad una applicazione RCP i passi da seguire sono fondamentalmente:

1. ottenere un oggetto Tray dopo aver aperto la finestra principale, quindi dall'interno dell'ApplicationWorkbenchWindowAdvisor;
2. si deve creare un TrayItem per ogni icona da visualizzare (tipicamente una sola);
3. associare ad ogni item un listener per l'evento MenuDetect (click destro/menu' contestuale) e creare nel modo abituale il menu con le relative azioni e contributi;
4. associare ad ogni item un listener per l'evento DefautlSelection per minimizzare/massimizzare la finestra principale (o un'altra parte dell'applicazione) quando l'utente fa click (sinistro) sull'icona nel tray.
5. Il codice seguente mostra come configurare il tray in modo semplice, associando al menu' contestuale le azioni About e Exit. Il metodo configureTray dovrebbe essere chiamato nel post-window-open.

   private void configureTray(){
    // get the workbench window
    final IWorkbenchWindow window = this.getWindowConfigurer().getWindow();
   
    // get the tray for the current running system
    Tray tray = window.getShell().getDisplay().getSystemTray();
   
    // the tray could be null if the system does not support it
    if( tray == null )
        return;
   
    // if here I've got a valid tray, create a tray item and configure it with an image
    TrayItem trayItem = new TrayItem( tray,  SWT.NONE );
    // set the icon
    ImageRegistry imgRegistry = Activator.getDefault().getImageRegistry();
    trayItem.setImage( imgRegistry.get( ... ) );
    // set the tooltip
    trayItem.setToolTipText("...");
   
   
    // add a menu listener on the tray element, so that it can
    // show the menu
    trayItem.addListener( SWT.MenuDetect, new Listener(){

        @Override
        public void handleEvent(Event event) {
        // create a new menu manager
        MenuManager manager = new MenuManager();
        // create the context menu
        Menu trayItemMenu = manager.createContextMenu( window.getShell() );
       
        // add entries to the menu
        manager.add( ActionFactory.ABOUT.create(window) );
        manager.add( ActionFactory.QUIT.create(window) );
       
        // the menu must be visible
        trayItemMenu.setVisible( true );       
        }
       
    });
   
   
   
    // add a listener to the tray icon, so that when the user double clicks
    // on the item the window is popped up again and made visible
    trayItem.addListener( SWT.DefaultSelection, new Listener(){

        @Override
        public void handleEvent(Event event) {
        Shell windowShell = window.getShell();
        if( ! windowShell.isVisible() )
            windowShell.setVisible(true);
       
        windowShell.setMinimized(false);
       
           
        }
       
    });
    }

RCP: aggiunta della log view ad una applicazione

Grazie alla modularità di Eclipse (e OSGi) è veramente semplice aggiungere una vista di "log" ad una applicazione RCP.

Come prima cosa occorre aggiungere alla applicazione la dipendenza del plugin org.eclipse.ui.views.log.

Successivamente occorre aggiungere il comando al proprio set di menu (o pulsanti o toolbar):

• selezionare l'elemento dove aggiungere il comando (ad esempio il menu') e aggiungere un nuovo comando con click destro -> New -> Command
• specificare le informazioni del comando con l'id rappresentato in figura

•  infine aggiungere al comando un parametro (click destro, New -> Parameter) e specificare l'id della vista da aprire come riportato in figura

 A questo punto l'applicazione visualizzerà il nuovo comando e aprirà la vista dei log dell'applicazione. Il sistema di loggin può essere usato in ogni punto dell'applicazione con il seguente frammento di codice:

ILog logger = Activator.getDefault().getLog();

StringBuffer buffer = new StringBuffer( 100 );

//.....
IStatus status = new Status( IStatus.INFO, 

                             Activator.PLUGIN_ID, buffer.toString() );
logger.log(status);

Eclipse RCP Preferences: memorizzare informazioni di login in uno splash screen interattivo

Eclipse RCP mette a disposizione dello sviluppatore un sistema complesso di preferenze che possono essere usate per salvare, ad esempio, informazioni di login. Le preferenze di Eclipse possono essere di due tipi fondamentali:

• in chiaro
• cifrate

Le ultime vengono salvate con un meccanismo a keyring e i plugin *.security forniscono tutti gli strumenti necessari al loro utilizzo. Ad esempio org.eclipse.equinox.security.ui permette la memorizzazione nel portachiavi con tanto di dialog per la configurazione del portachiavi stesso. 

Si pone tuttavia un problema per l'utilizzo delle preferenze cifrate: il workspace deve esistere ed essere in esecuzione. Ciò significa che lo sviluppatore ha piu' lavoro da svolgere nel caso in cui le preferenze siano usate da applicazioni RCP headless o, come nel mio caso, da splash screen interattivi (che agiscono prima del workspace stesso).

Qui sotto riporto un esempio di utilizzo di un motore di salvataggio/caricamento dei dati dell'ultimo utente che ha effettuato il login nell'applicazione. In questo caso occorrerebbe salvare i dati in modo cifrato, ma essendo il mio un caso di splash screen interattivo, e trattandosi di dati comunque non fondamentali (poiché nella mia applicazione esistono altri meccanismi di sicurezza), ho deciso di usare per semplicità le preferenze in testo semplice. Da notare che il motore qui sotto proposto estrae ed inserisce i dati in un oggetto User che funge da wrapper per la business logic dietro all'utente stesso.

public class UserPreferencesStorage {

    private String PREFERENCES_USER_ROOT_NODE = "saved-user";
    private String PREFERENCES_USERNAME_NODE  = "username";
    private String PREFERENCES_PASSWORD_NODE  = "password";
    private String PREFERENCES_USER_PK_NODE   = "userpk";

 
    /**
     * Saves the preferences of the provided user.
     * @param user the user that must contain the password and the username to store
     * @return true if the storage has been done
     */
    public boolean saveUserPreferences( User user ) throws BackingStoreException{
 try{
     // get the normal preferences and the scope for this plugin
     IEclipsePreferences preferences = new ConfigurationScope().getNode( Activator.PLUGIN_ID );
     // now get the main node for the configuration storage
     Preferences savedPreferences = preferences.node(PREFERENCES_USER_ROOT_NODE);

     // now store the username and the password
     savedPreferences.put( PREFERENCES_USERNAME_NODE, user.getUsername() ); 
     savedPreferences.put( PREFERENCES_PASSWORD_NODE, user.getPassword() ); 
     savedPreferences.put( PREFERENCES_USER_PK_NODE, user.getPrimaryKey() + "" );  
     
     // flush the storage to ensure everything is written to disk
     preferences.flush();
     
     // all done
     return true;
     
 }catch( BackingStoreException se ){
     // log the exception and do nothing, cannot save
     IStatus status = new Status( IStatus.ERROR,     // severity
      Activator.PLUGIN_ID,      // the id of the application/plug-ing
      "Errore nel salvataggio delle preferenze di login utente",  // message
      se
     );

     throw se;
 }

    }
    
    
    /**
     * Loads a user from the prefences store.
     * @return the user loaded or null
     */
    public User loadUser() throws StorageException{
 // get the normal preferences and the scope for this plugin
 IEclipsePreferences preferences = new ConfigurationScope().getNode( Activator.PLUGIN_ID );
 // now get the main node for the configuration storage
 Preferences savedPreferences = preferences.node(PREFERENCES_USER_ROOT_NODE);
 
 // get the values from the storage
 String username  = savedPreferences.get(PREFERENCES_USERNAME_NODE, "");
 String password  = savedPreferences.get(PREFERENCES_PASSWORD_NODE, "");
 String primaryKey  = savedPreferences.get(PREFERENCES_USER_PK_NODE, "0");
 
 
 // create the user with such values
 User user = new User( Integer.parseInt(primaryKey), username, password );
 
 // all done
 return user;
    }
}