mercoledì 29 dicembre 2010
Considerazioni sui dischi esterni
mercoledì 15 dicembre 2010
OpenBSD Security
martedì 14 dicembre 2010
Eclipse Visual Editor
Nebula Table Combo
this.combo = new TableCombo( this , SWT.READ_ONLY );
// say I want two columns
this.combo.defineColumns( new String[]{ "ID", "Descrizione" } );
this.combo.setShowTableHeader( true );
// the description is the column used for the selection
this.combo.setDisplayColumnIndex( 1 );
TableItem tableItem = new TableItem( this.combo.getTable(), SWT.NONE );
tableItem.setText(
new String[]{ newElement.getId(), newElement.getDescription() } );
PL/Java e Transazioni Distribuite
Il quesito riguardava l'utilizzo di PL/java per comandare un ambiente enterprise ed eventualmente avviare una transazione distribuita. Cosa succede in questo caso? La risposta è semplice: PL/Java esegue all'interno del processo backend di PostgreSQL e quindi la transazione è confinata all'interno del backend stesso. Il processo backend non sa nulla di quello che PL/Java, che tuttavia esegue come processo esterno, sta facendo, e quindi non c'è modo di collegare la transazione/statement di PostgreSQL ad una eventuale transazione distribuita orchestrata da PL/Java. E' il programmatore PL/Java che deve farsi carico di tutto quanto.
Ad ogni modo, ho voluto chiarire questa faccenda sulla mailing list di PL/Java, qui si trova la discussione ufficiale.
venerdì 10 dicembre 2010
PGDay 2010: un altro successo marcato ITPug. Un altro successo della community.
Ogni anno mi rendo sempre piu' conto che il PGDay non e' solo una giornata o un evento tecnico incentrato su PostgreSQL, bensi' un incontro della comunita', una comunita' di sviluppatori, di appassionati, di professionisti e in generale di gente che ne vuole sapere di piu'.
E come e' ormai tradizione, il PGDay 2010 inizia davanti ad una birra, in un ristorante di Roma, in attesa che un bel piatto di pasta (amatriciana o carbonara le uniche opzione scelte da noi DBA/sviluppatori) fumante ci sfami. Il tavolo e' denso di personalita' dal carisma e dalla competenza eccezzionale: oltre a noi italiani vi e' infatti Simon Riggs, intento a divorare una fiorentina decisamente esagerata anche per le sue capacita', e Jonhatan Katz impegnato con una piu' modesta pizza. Si parla ovviamente di PostgreSQL ma non solo: ogni argomento tecnologico e' valido per essere messo sul tavolo, cosi' come ogni cosa che rigurardi la comunita' e la cultura Open Source. Le discussioni con Daniele, Emanuele e il sempre intraprendente Torello sono avvincenti e illuminanti.
Simon Riggs apre le danze con una introduzione su PostgreSQL 9 veramente d'effetto, non solo per l'alto livello tecnico e la chiarezza espositiva, ma anche per il saper comunicare efficacemente il vero valore aggiunto di PostgreSQL. E infatti si inizia gia' a parlare di quello che sara' un tema ricorrente nella giornata: il fattore economico. Vale la pena ricordare come PostgreSQL offra funzionalita' comparabili, identiche (e in alcuni casi anche superiori) a quelle di altri database commerciali senza richiedere costi di licenza. E' quindi evidente come la scelta di soluzioni professionali basate su PostgreSQL possa portare ad un risparmio economico anche notevole, soprattutto in un periodo, questo, nel quale le aziende e le amministrazioni faticano a far quadrare i bilanci.
A nome personale e di ITPug vorrei ringraziare tutti i volontari che hanno reso possibile questa grande festa di PostgreSQL: Diego, Simone, Marco, Torello, Emanuele, Daniele, Gianluca, Gabriele, Gianni senza nulla togliere a tutti gli altri.
venerdì 3 dicembre 2010
Nuovi libri su PostgreSQL
Compilazione di Nebula
- creare una cartella che conterrà tutto il progetto;
- effettuare il login anonimo al server CVS
- scaricare l'albero dei sorgenti e dei progetti di Nebula:
- e infine compilare i progetti org.eclipse.swt.nebula.nebula-incubation (ancora non stabili) e org.eclipse.swt.nebula.nebula-release (stabili): occorre entrare nella directory di ogni progetto e dare il comando mvn install. Ogni progetto avrà poi una cartella target che conterrà il jar finale.
giovedì 2 dicembre 2010
RCP: tray icon
Per aggiungere una icona tray ad una applicazione RCP i passi da seguire sono fondamentalmente:
- ottenere un oggetto Tray dopo aver aperto la finestra principale, quindi dall'interno dell'ApplicationWorkbenchWindowAdvisor;
- si deve creare un TrayItem per ogni icona da visualizzare (tipicamente una sola);
- 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;
- 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.
- 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);
}
});
}
martedì 30 novembre 2010
SWT CLabel
venerdì 26 novembre 2010
L'importanza delle convenzioni dei nomi
- si scrive un DAO per il caricamento diretto di un Person, di un Department e di un join fra i due. Ovviamente questa soluzione non è molto pratica;
- si creano delle viste su tutte le tabelle in modo che i dati ritornati siano sempre person_ID, person_description, department_ID, department_description sia per le query "semplici" che per i join. Ma questo richiede la scrittura di codice aggiuntivo e non molto utile;
- si usa una convenzione differente nei nomi delle colonne: ogni colonna viene nominata con un prefisso che corrisponde al nome della tabella: person( personID integer, personDescription text ) e department( departmentID integer, departmentDescription text ). Così facendo i DAO vengono scritti sempre per colonne che sono univoche nel sistema, anche quando le tabelle vengono messe in join.
giovedì 25 novembre 2010
Università e professionisti... alcune riflessioni (parte 2)
RCP: aggiunta della log view ad una applicazione
- 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
IStatus status = new Status( IStatus.INFO,
logger.log(status);
Nuovi supporti tecnologici per Gigetto
- un potente faro luminoso che sovrasta la zona delle biciclette a noleggio. Chissà, forse qualcuno si è accorto che la stazione era rimasta al buio per troppo tempo ed era quindi diventata facile preda di vandali e maleducati!
- un nuovo display luminoso che segnala ora, treni in arrivo e relativo ritardo. Peccato che tale tabellone continui a segnare un orario sbagliato e quindi informi in modo totalmente sbagliato gli utenti in viaggio. Avevo già descritto questi pannelli luminosi, che visti in azione mi ricordano tanto la mia prima applet Java che faceva scorrere una scritta sullo schermo spostandola ad intervalli di 1 secondo. Tale tabellone fa la stessa cosa, e non è per niente sincronizzato con i treni in transito o con una delle stazioni di scambio.
E come volevasi dimostrare, dopo appena una settimana il pannello luminoso mostra una evidente crepa causata, certamente, da una sassata. E come se non bastasse continua a segnare l'orario sbagliato...
Eclipse RCP Preferences: memorizzare informazioni di login in uno splash screen interattivo
- in chiaro
- cifrate
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; } }
giovedì 18 novembre 2010
Università e professionisti...alcune considerazioni
ma basate sulla mia esperienza diretta.
Anzitutto ritengo che le università, in generale, siano troppo slegate dal mondo lavorativo senza quindi avere idea dei problemi che tale mondo sta affrontando. Ci si trova quindi nella condizione nella quale le università lavorano a progetti estremamente innovativi il piu' delle volte spinti non da problemi del mondo lavorativo ma da interessi puramente di ricerca. E per fortuna: sono un forte sostenitore dell'iniziativa individuale. Tuttavia ci si trova anche nella condizione ove, per dimostrare che il proprio lavoro scientifico è valido, si debbano trovare i problemi che la propria ricerca risolve. Ma questo è un modo sbagliato di ragionare: è meglio partire dal problema e trovare la soluzione, piuttosto che avere l'intuizione e cercare il problema che risolve (o il contesto ove collocarla). Così facendo infatti si rischia solo di produrre soluzioni per un mercato non ancora pronto, e infatti molto spesso i risultati della ricerca scientifica vengono applicati diversi anni dopo al mondo lavorativo. E non si tratta di tempi canonici per la stabilizzazione della soluzione, ma semplicemente di tempi nei quali il mercato non è recettivo poiché occupato a risolvere altri problemi che le università reputano banali e quindi non prendono in considerazione.
Ulteriore ostacolo al dialogo fra il mondo del lavoro e delle università sono, molto spesso, i professori stessi: ogni professore ha un suo ambito di ricerca/interesse e tenta di forzare tale ambito ai suoi studenti, stabilendo spesso anche confini ben marcati che separino la propria ricerca da quella dei colleghi. Ci si ritrova quindi con studenti che svolgono attività di ricerca in un ambito (es. database) senza mettere il becco in altri ambiti (es. sistemi operativi) per volontà dei loro professori. I professori dovrebbero invece mettere a disposizione la loro esperienza affinché gli studenti, preso in carico un problema concreto del mondo del lavoro, possano affrontarlo e risolverlo agevolmente. E in questo modo si avrebbero diversi vantaggi:
- le aziende acquisterebbero molta fiducia nelle università;
- gli studenti acquisterebbero fiducia nelle proprie capacità (meglio 10 successi piccoli ma certi che un grande successo non applicabile al mercato);
- gli studenti troverebbero da lavorare piu' facilmente, avendo maturato una esperienza diretta nel mondo del lavoro;
- i professori resterebbero automaticamente aggiornati sulle problematiche del mercato.
- rilasciare un progetto come OpenSource significa dare al mondo (e quindi ad altre università) i propri sforzi di ricerca;
- un progetto OpenSource potrebbe vedere la partecipazione di altri professionisti o università che mostrino una superiorità schiacciante in tale ambito.
Torniamo ora all'argomento di discussione specifico: il possibile contrasto fra i professionisti e gli accademici. Di cosa dovrebbero avere paura i professionisti? Dopotutto, la loro professionalità non dovrebbe essere messa in discussione da un qualche professore o studente che si presenta sul mercato: quello che conta, che si tratti di professore, studente, o libero professionista, è l'esperienza e l'abilità, due qualità che non possono essere conquistate stando solo dietro ad una cattedra o solo nel mondo del lavoro. Io, da ingegnere, non temo il confronto onesto con un altro ingegnere, e poco mi importa sia un docente, uno studente o un professionista: per quello che riguarda il confronto è solo un mio "sfidante". Quali scenari dunque si prospettano e perché spaventano tanto i professionisti? Io riesco ad individuare queste possiblità:
- l'università inonda il mercato con personale a basso costo e alta qualità: il prezzo dei professionisti è costretto ad abbassarsi di conseguenza per poter reggere la concorrenza, e questo è un bene per chi richiede il servizio;
- l'università inonda il mercato con personale a basso costo e bassa qualità: è evidente che tale personale non sarà in grado di fornire un servizio alla pari di quello di un professionista esperto, e quindi tale categoria non ha nulla da temere da questo confronto. Va inoltre notato che un professionista non può tutelarsi da questa problematica che non è infatti legata al mondo accademico.
- l'università inonda il mercato con personale ad alto costo e di alta qualità: in questo caso i professionisti occupano la seconda posizione nelle scelte mission critical, ma il loro costo inferiore li rende una scelta papabile per tutti gli altri casi.
- l'università inonda il mercato con personale a basso costo, bassa qualità da affiancare a personale professionale: in questo caso si assiste alla formazione di un nuovo professionista a "discapito" di un altro professionista. Ma occorre ricordare che quest'ultimo sarà stato a sua volta formato (si spera) a "discapito" di un docente universitario...
Anni fa una protesta analoga venne fatta dal lato accademico, spaventato dal possibile ingresso di industrie e professionisti nel loro "regno". E anche in quella occasione io evidenziai i miei dubbi su tanta rigidità: dopotutto aprire l'università all'industria significa, come già detto sopra, aprire la strada a nuovi posti di lavoro. Rolando, che a difesa della sua tesi sottolinea il periodo di crisi del mercato, dovrebbe tenere in considerazione anche questo fattore: dare spazio di lavoro ai giovani significa aumentare l'occupazione, non aumentare la disoccupazione dei professionisti. E quindi mi viene solo da ribadire come ognuno dovrebbe smettere di guardare al prioprio orticello, ma assumere una visione piu' ampia della questione.
Come riflessione conclusiva mi viene in mente che, se entrambe le parti, in tempi e con motivazioni diverse, non vogliono mischiarsi, forse il vero problema non è tanto sulle competenze, sulle capacità, sulla professionalità, ma sulla mancanza di un confronto onesto che tuteli entrambi i lati affinché solo chi è meritevole possa avere successo.
Ma forse sono io che non ho ben capito il reale problema....
martedì 16 novembre 2010
SWT Virtual Table: problemi di sorting
sabato 13 novembre 2010
OpenSolaris promo t-shirt
venerdì 12 novembre 2010
Eclipse Labs
mercoledì 10 novembre 2010
Nebula download corrotto
RCP: ottenere le informazioni di plugin a run-time (immagini e versione del prodotto)
IProduct product = Platform.getProduct();
// get my shell
Shell myShell = ...
// the product can be null if the running instance is launched
// as an eclipse application (e.g., during the development)
if( product == null )
return;
// get the bundle symbolic name
String bundleID = product.getDefiningBundle().getSymbolicName();
// get the array of the application icons (defined thru the product)
// the method will return a single string with the list of images
// used at different sizes (16x16, 32x32, 48x48 and so on). The list is
// comma separated, so I need to extract every single item.
String imagePaths = product.getProperty(
List
StringTokenizer commaTokenizer = new StringTokenizer(imagePaths, ",");
while( commaTokenizer.hasMoreTokens() )
imagePathList.add( commaTokenizer.nextToken() );
// now that I've got the list of image paths (separated)
// single image using an ImageDescriptor
Image[] windowImages = new Image[ imagePathList.size() ];
for( int i = 0; i < imagePathList.size(); i++ ){
ImageDescriptor currentDescriptor =
imagePathList.get(i) );
windowImages[ i ] = currentDescriptor.createImage();
}
// now set the images for this window
myShell.setImages( windowImages );
// get the window configurer object
IWorkbenchWindowConfigurer configurer = this.getWindowConfigurer();
// set the title of the window
StringBuffer title = new StringBuffer( 100 );
title.append( "My App" ); // the fixed part of the title
// get the information from the product
IProduct product = Platform.getProduct();
if( product == null )
title.append( " [Eclipse Application - Development]" );
else{
title.append( " [RCP Product -" );
title.append( product.getName() );
title.append( " ~~ " );
// get some information from the bundle
Bundle definingBundle = product.getDefiningBundle();
title.append(" ID: " );
title.append( definingBundle.getSymbolicName() );
title.append(" ~~ Ver.: " );
title.append( definingBundle.getVersion() );
}
// set the real title
configurer.setTitle( title.toString() );
martedì 9 novembre 2010
KMail: migrare le impostazioni delle cartelle
#!/usr/bin/perl open( KMAILRC, "<$ARGV[0]" ) || die("\nCannot open the specified kamilrc file\n$!\n"); open( EMAILIDENTITIES, "<$ARGV[1]")|| die("\nCannot open the email identities file\n$!\n"); open( NEWCONFIG, ">kmailrc.new" ) || die("\nCannot open the new configuration file\n$!\n"); $emailAddress = $ARGV[2]; $IDENTITY = undef(); # first step: find the identity id while( ($line =) && (! defined($IDENTITY) ) ){ chomp( $line ); if( $line =~ /$emailAddress/ ) { print "\nFound e-mail addrress $line"; while( ($line = ) && (! defined( $IDENTITY ) ) ){ if( $line =~ /uoid/ ){ $line =~ s/(uoid=)(.*)/$2/; $IDENTITY = $line; print "\nFound an identity uoid = $IDENTITY\n"; } } } } $FolderKey = $ARGV[3]; while( $line = ){ chomp( $line ); if( $line =~ /\[Folder-\.$FolderKey/ ){ chomp( $line ); print NEWCONFIG $line , "\n"; print "\nFound folder $line\n"; $doneThisFolder = ""; while( ($innerLine = ) && (! $doneThisFolder ) ){ chomp( $innerLine ); if ( $innerLine =~ /UseDefaultIdentity/ ){ print NEWCONFIG "UseDefaultIdentity=false\n"; print NEWCONFIG "Identity=$IDENTITY\n"; $doneThisFolder = "true"; } elsif( $innerLine =~ /Identity/ ){ # print nothing, it has already be printed in the # UseDefaultIdentity identity } else{ print NEWCONFIG $innerLine , "\n"; } } } else{ print NEWCONFIG $line , "\n"; } }
lunedì 8 novembre 2010
Programma PGDay 2010
lunedì 18 ottobre 2010
Nuove community dopo l'acquisizione da parte di Oracle di Sun
- OpenIndiana che promette di portare avanti (e a termine) lo sviluppo di OpenSolaris. OpenIndiana a sua volta è figlio di un progetto nato ad Agosto, quando la OpenSolaris Governing Board non ricevette alcuna risposta da Oracle, denominato Illumos. E OpenSolaris (il sistema operativo) che fine ha fatto? Il sistema diventerà il nuovo Solaris 11, e dal sito web ufficiale è sparito il comodo link per scaricare la developer build, ora piu' nascosto, mentre il download ufficiale punta alla versione 2009.06. Di fatto ogni tentativo per tenere in vita un colloquio fra la community di OpenSolaris e Oracle è stato vano:
All of Oracle’s efforts on binary distributions of Solaris technology
will be focused on Solaris 11. We will not release any other binary
distributions, such as nightly or bi-weekly builds of Solaris
binaries, or an OpenSolaris 2010.05 or later distribution. We will
determine a simple, cost-effective means of getting enterprise users
of prior OpenSolaris binary releases to migrate to S11 Express.
- LibreOffice è una comunità nata attorno al progetto OpenOffice con il chiaro intento di produrre una suite per ufficio libera, come lo è stata OpenOffice, senza però nessuna azienda che ne governi il ciclo di vita.
giovedì 14 ottobre 2010
PGDay 2010
SWT Widget Disposed & asyncExec
- i job, simili a dei thread Java contengono il codice da eseguire secondo una politica di schedulazione (anche immediata)
- gli sync/asyncExec, ossia l'esecuzione di un Runnable appena il thread grafico (UI Thread) può
org.eclipse.swt.SWTException: Failed to execute runnable (org.eclipse.swt.SWTException: Widget is disposed)
giovedì 7 ottobre 2010
Ottenere informazioni su generics a run-time
// get the superclass definition as a generic one
ParameterizedType genericSuperClass = (ParameterizedType) this.getClass().getGenericSuperclass();
// now get the first argument of the class
return (Class) genericSuperClass.getActualTypeArguments()[0];
}
venerdì 1 ottobre 2010
Kubuntu 10.04 & Network Management Disabled
Quando il network manager continua, insistentemente, a riportare che il network management è disabilitato, la soluzione consiste nel:
- editare il file /var/lib/NetworkManager/NetworkManager.state impostando lo stato del networking da disabilitato ad abilitato (NetworkingEnabled=true)
- riavviare il servizio di network management con service network-manager restart
Gnome 3, Kde 4, libertà e l'inversione di progetto
Ho usato KDE fin dalla prima versione, e contemporaneamente Gnome da quello che fu' la prima versione stabile (October Gnome). Ho seguito attentamente l'evoluzione di entrambi gli ambienti, preferendo sempre KDE poiché piu' funzionale e completo. Ho studiato le librerie GTK+ (fondamento di Gnome) e quelle Qt (fondamento di KDE). Penso quindi di conoscere bene i due DE (Desktop Environment) per poterne fare una ulteriore analisi.
Una delle principali accuse rivolte dalla comunità Gnome a quella KDE con l'uscita del ramo 4.x è stata la rivoluzione operata da quest'ultimo: basti pensare che perfino Linus Torvalds, estimatore del desktop del drago, lo ha abbandonato in favore di Gnome perché KDE 4 ha rivoluzionato, forse troppo rapidamente, il modo di fare desktop. Non esiste piu' infatti un concetto di desktop statico, con un pannello, delle icone, e dei menu', ma un sistema di applet (dette Plasmoids) che possono contenersi l'un l'altra. Allora l'applet che indica il livello di carica della batteria può essere messa sul desktop, o sul pannello, o dentro ad un menu', poiché la struttura è "circolare". Ma questo significa anche che il desktop non è piu' un semplice contenitore di cartelle e file (icone), ma una vera piattaforma operativa. Gnome di contro si presenta ancora in versione "semplice", e sicuramente piu' vicina all'utilizzo classico di utenti tradizionali. Ma Gnome 3 cambierà tutto: ho provato la shell su un pc dedicato e devo dire che la rivoluzione sarà pesante anche per gli utenti Gnome. In particolare non capisco perché, per aprire un menù, l'utente sia costretto a vedere ridimensionato l'intero desktop.
Caduta quindi la tesi rivoluzionaria di KDE, vorrei analizzare i due progetti da altri punti di vista. Anzitutto dal nome: Gnome significa GNU Network Object Model Environment, ossia sistema ad oggetti trasparenti alla rete e, per ammissione del suo fondatore Miguel De Icaza, un sistema con idee prese in prestito dal COM di Microsoft. KDE invece significa Kool Desktop, ed è un ovvio gioco di parole sul CDE. Ad oggi KDE è molto piu' network oriented di Gnome, visto che i plasmoid possono essere condivisi sulla rete da un computer all'altro, il desktop rende realmente ogni operazione trasparente alla rete. Gnome invece si è fossilizzato sul classico desktop, sicuramente funzionale, ma non così network oriented come si era ripromesso. Si è quindi arrivati ad una inversione di progetto: KDE è nato per fornire un desktop efficiente ed efficace, ed oggi è network oriented, Gnome invece era piu' ambizioso e oggi si propone come desktop "statico".
Ma c'è anche un altro punto fondamentale: la libertà. Gnome nasce su volontà della GNU, proprio per contrastare i problemi di licenza delle Qt, e quindi si propone di fatto come desktop libero. Però la versione 1.x di Gnome non piace molto, o meglio viene sorpassata da KDE in tutto e per tutto. Si deve aspettare l'intervento di grossi vendor come Sun, IBM, RedHat, che investendo sul desktop della scimmia creano quella usabilità di Gnome 2. KDE invece non ha aziende alle sue spalle, solo la comunità di sviluppatori. Quindi, paradossalmente, KDE è piu' libero di Gnome, visto che il primo si evolve come gli sviluppatori vogliono, mentre il secondo come vogliono i vendor. Per meglio comprendere questa cosa si pensi ad Ubuntu e Kubuntu: il primo fornisce codice indietro a Gnome, ma crea personalizzazioni per attirare piu' utenti (ad esempio il recente visualizzatore/controllore audio integrato nel menù del volume), il secondo fornisce una pura installazione KDE senza personalizzazioni. Ancora si pensi ad OpenSolaris (e derivati) che hanno implementato plugin appositi (ad esempio TimeSlider per Nautilus) solo per la versione Gnome, mentre KDE non giova nemmeno del supporto della piattaforma.
Infine si pensi all'innovazione tecnologica di KDE: chi ammira i prodotti Apple dovrebbe ricordarsi che WebKit, la piattaforma Web di KDE, ha dato vita a Safari e alla dashboard, così come i plasmoidi sono eseguibili nativamente su KDE. In altre parole, KDE e OSX hanno molto in comune, grazie agli sforzi del primo.
Quindi quali sono i vantaggi e gli svantaggi nell'uso dei due DE? I vantaggi nell'uso di Gnome sono la semplicità e il supporto dei vendor, che garantisce una buona interoperabilità hardware/software. Gli svantaggi sono la scarsa personalizzazione (se raffrontata a KDE) e la scarsa tecnologia. I vantaggi nell'uso del KDE sono la grande innovazione tecnologica, la grande possibilità di personalizzazione e l'interoperabilità con altre piattaforme. Gli svantaggi sono il suo sviluppo, troppo legato agli sviluppatori che quindi creano tool complessi per utenti esperti (in linea con la filosofia Unix) e non si curano troppo degli utenti alle prime armi.
E come nota conclusiva segnalo che il passaggio alle GTK+ 3 non è stato preso attentamente in considerazione da IBM (che sicuramente recupererà), mentre so che è in corso un porting delle SWT su Qt.
mercoledì 29 settembre 2010
WhiteCat: scheduling tasks depending on role events
- the task to schedule (of course)
- an agent that must perform the task or any agent that is able to do the task (i.e., any agent that is going to assume/release the role the task belongs to)
- when the task must be executed (after the role assumption or before the role release)