Programming & more...

User Centered Design Economico (in Italiano)

2012-09-08T10:12:00.000+02:00

User Centered Design Economico

Progettazione centrata sull’utente

con l'impiego minimo di risorse

di Vincenzo Dentamaro 27/07/2012

Prefazione:

Lo User Centered Design (UCD) è un modo per progettare e costruire prodotti di qualsiasi genere tenendo conto del punto di vista e delle esigenze dell’utente. Lo UCD è un processo composto di più attività. Si basa sull’iterazione di diversi strumenti di analisi od osservazione, progettazione e verifica. In italiano questo processo è noto anche come “Progettazione Centrata sull’Utente”.

Il processo è stato definito e descritto da diversi autori e persino da alcune norme ISO, come l’ISO 13407, Human-centered design process, l’ISO 9241-110 Dialogue Principles (mod. 2006). Diverse fonti descrivono processi leggermente diversi, ma guidati dalla stessa filosofia: fondare il progetto sui reali bisogni degli utenti.

Secondo l’ISO 13407:

In questa tesi presenterò un modello di User Centred Design che permetterà di sviluppare prodotti e servizi tenendo presente non solo le reali esigenze degli utenti, ma anche le esigenze di economicità in fase di sviluppo di un prodotto (o servizio) da parte delle aziende.

Conoscere l’utente

Tutto si basa sul coinvolgimento attivo dell'utente e sulla chiara comprensione dei requisiti degli utenti e dei task (quello che l’utente deve fare).

Bisogna comprendere quello che l’utente fa, come lo fa e cosa si aspetta come output.

Analizzare gli utenti basandosi sui seguenti punti:

Capacità e bisogni reali
Contesto
Lavoro
Tasks
Necessità di prodotti usabili

Golden rule del progetto di interfacce: Conoscere l’utente.

Per conoscere l’utente bisogna osservarlo mentre compie il suo lavoro (non ancora automatizzato e privo della nostra soluzione), cosa si aspetta in output e capire come tutto può essere automatizzato o semplificato mediante l’uso di una soluzione (prodotto o servizio) differente.

E’ conveniente descrivere uno scenario, cioè scrivere, in maniera semi-formale, una storia di come gli utenti usano la soluzione attuale per compiere i loro task.

Approfondendo aspetti caratteristici degli utenti come il loro background cognitivo (quanto conoscono di una certa cosa), le loro abilità motorie e mentali (se hanno deficit cognitivi o motori), l’età (un prodotto per bambini deve poter essere usato diversamente da come lo userebbe un adulto), l’ambiente in cui vive, la cultura, la propria storia.

Fondamentalmente dopo questa analisi vengono fuori due grandi categorie di utenti:

Gli utenti comuni e gli utenti speciali.

Gli utenti comuni sono quegli utenti che non hanno particolari deficit motori o cognitivi e che rappresentano la maggiorparte degli utenti del nostro prodotto.

Gli utenti speciali sono quegli utenti che per necessità d’uso o per deficit cognitivi o motori hanno bisogno di una qualche progettazione speciale per adattare il prodotto ancora da sviluppare alle loro esigenze.

Se si desidera creare un prodotto usabile (cioè il grado con cui un essere umano può utilizzarlo con il massimo profitto e il minimo sforzo) anche per gli utenti speciali, è sempre conveniente pensare alla soluzione prima di iniziare lo sviluppo:

Molte aziende creano un prodotto per l’utente comune e poi applica degli adattamenti per l’utente speciale (tipo plugin), questo rende il prodotto poco usabile per l’utente speciale.

Si dovrebbe quindi prevedere la progettazione orientata all’utente speciale sin dall’inizio.

La più recente ricerca sull’usabilità dimostra che la soluzione migliore per creare un sitema usabile per l’utente speciale è quella di progettare un sistema in grado di adattarsi alle caratteristiche dell’utente man mano che l’utente lo usa.

Quindi pensare a chi è destinato l’uso del prodotto da sviluppare.

Osservare l’utente mentre svolge il task

Continuare la descrizione dello scenario inserendo una descrizione abbastanza approfondita di quello che l’utente fa per arrivare al suo scopo, come lo fa, usando quali strumenti e se è soddisfatto o meno.

Questa analisi ci permetterà di capire il dominio applicativo del prodotto da sviluppare e addirittura di collocare il prodotto da sviluppare in uno preciso contesto lavorativo.

L’analisi deve produrre come output una lista strutturata di task che l’utente compie per raggiungere lo scopo. Poi il progettista annota ciascun task come necessario, non importante, importante, auspicabile ed ecc.

Ecco un esempio riguardo l’analisi dei task per un progetto sul financial forecasting:

F.S. è un responsabile del gruppo Emea di IBM Italia e desidera conoscere quando vendere le azioni di IBM in suo possesso da 10 anni.

Francesco, come qualsiasi altro dipendente di IBM, riceve annualmente come premio delle Stock Options, ovvero dei pacchetti di azioni dell’azienda presso cui presta servizio. Vuole sapere qual’è il momento migliore per vendere le proprie azioni e ricavare denaro fisico da investire per comprare una casa ad Ostia ai figli. Francesco conosce molto bene l’uso delle tecnologie informatiche ed è un curioso sperimentatore di nuovi strumenti software. Utilizza giornalmente Yahoo Finance! per vedere qual’è il valore corrente delle azioni di IBM Inc. ed inoltre usa altri siti di brokerage online (come www.interactivebrokers.com) per trovare dei compratori per le proprie azioni e realizzare la cifra di cui necessita per acquistare la casa al mare ai figli.

Nello specifico Francesco legge sulla sua pagina personale di IBM il numero di azioni da lui detenute e il valore corrente del titolo “IBM” e quindi il valore totale delle sue azioni.

Poi si reca su Yahoo! Finance, cerca e seleziona il titolo “IBM” e visualizza l’andamento storico del titolo “IBM” inerente ai mesi passati. L’andamento è presentato in maniera grafica mediante un diagramma. Una volta osservato il diagramma, se il grafico è in crescita o è stabile Francesco si reca su alcuni siti di brokerage online per vendere le proprie azioni.

Vorrebbe conoscere l’andamento futuro del valore del titolo di IBM ma proprio non ha alcuna idea di come predire il futuro.

Nei siti di brokerage usa spesso lo strumento in modalità demo per simulare l’acquisto e la vendita di azioni. E’ diffidente nell’uso di strumenti di vendita di azioni online, perché consapevole dei rischi di frode che potrebbero esserci. Però non vuole neanche affidarsi a dei costosi e a volte poco onesti, brokers fisici (persone) che svolgono quel lavoro come professione. Per questo motivo rimanda sempre la vendita delle sue azioni sperando di non arrivare mai a raggiungere valori minimi di quotazione oppure raggiungere la scadenza delle stock options in suo possesso. Conoscere l’andamento futuro delle proprie azioni gli permetterebbe di capire qunado vendere le sue azioni e quanto guadagnerà o perderà continuando a tenersele senza venderle.

Francesco è un utente diretto del sistema, primario, perché quotidianamente valuterà l’andamento presente e futuro dei titoli ed è un utente esperto di tecnologie informatiche ma non esperto di finanza.

Francesco, rappresenta la categoria di utenti che usa frequentemente sistemi online per monitorare l’andamento delle azioni, però, a differenza della categoria precedente, lo fa per cogliere il momento giusto per venderle e guadagnare di più.

Sotto task individuati:

Lettura del valore corrente del titolo

Importante e Frequente
Da includere assolutamente

Lettura del valore totale delle stock options di cui si è in possesso

Importante per Francesco
Non frequente

Recarsi su Yahoo! Finance

Relativamente frequente
Importante
Non importante in un software che ha le stesse funzionalità di Yahoo! Finance.

Ricerca dell’azienda

Importante e Frequente
Da includere assolutamente

Selezione dell’azienda

Da includere assolutamente
Frequente e importante

Selezione dell’intervallo (la data di inizio e la data di fine) in cui prelevare i valori giornalmente

Molto importante e Frequente
In futuro renderlo opzionale potrebbe diminuire la complessità del sistema

Visualizzazione di un grafico dell’andamento dei valori storici

Frequente ed importante
Da includere assolutamente

Vendita di azioni mediante strumenti online

Frequente
Possibile implementazione futura

Simulazione di vendita online

Non frequente
Non importante

Rinuncia alla vendita/acquisto

Frequente
Importante
Possibile implementazione futura

Come potete notare non si accenna minimamente alla soluzione da progettare, queste analisi dei task hanno il solo scopo di individuare gli utenti, cosa fanno e come lo fanno.

Sta al progettista poi capire cosa includere e cosa non includere.

Analizzare più utenti significa avere un quadro completo di ciò che gli utenti desiderano dal prodotto.

Analisi dei requisiti

Un requisito (dal latino requisitus, richiesto) è una proprietà richiesta, oppure auspicabile, del prodotto.

Il documento dei requisiti ha allora lo scopo di raccogliere in forma organica una descrizione di tutte le proprietà desiderate. Dalla sua formulazione dovrebbe essere chiaro se un requisito esprime una proprietà obbligatoria, oppure soltanto suggerita o auspicabile.

I principali metodi di raccolta dei requisiti del progetto sono:

- Questionari: Rispondere a domande specifiche. Si possono raggiungere molte persone con poco sforzo. Vanno progettati con grande accuratezza, in caso contrario le risposte potrebbero risultare poco informative. Il tasso di risposta può essere basso;
- Interviste individuali: Esplorare determinati aspetti del problema e determinati punti di vista. L’intervistatore può controllare il corso dell’intervista, orientandola verso quei temi sui quali l’intervistato è in grado di fornire i contributi più utili. Richiedono molto tempo. Gli intervistati potrebbero evitare di esprimersi con franchezza su alcuni aspetti delicati.
- Focus group: Mettere a fuoco un determinato argomento, sul quale possono esserci diversi punti di vista. Fanno emergere le aree di consenso e di conflitto. Possono far emergere soluzioni condivise dal gruppo.La loro conduzione richiede esperienza. Possono emergere figure dominanti che monopolizzano la discussione.
- Osservazioni sul campo: Comprendere il contesto delle attività dell’utente. Permettono di ottenere una consapevolezza sull’uso reale del prodotto che le altre tecniche non danno. Possono essere difficili da effettuare e richiedere molto tempo e risorse.
- Suggerimenti spontanei degli utenti: Individuare specifiche necessità di miglioramento di un prodotto. Hanno bassi costi di raccolta. Possono essere molto specifici. Hanno normalmente carattere episodico.
- Analisi della concorrenza e delle best practices: Individuare le soluzioni migliori adottate nel settore di interesse: evitare di “reinventare la ruota” e ottenere vantaggio competitivo L’analisi di solito è costosa(tempo e risorse)

Valutare quali sono i più economici per il prodotto che si intende sviluppare ed applicarli.

E' consigliato creare una tabella dei requisiti dove viene specificato, per ogni requisito, anche la proprietà se obbligatoria, suggerita o auspicabile.

Creazione dei prototipi: pensare all’interfaccia!

La fase di progettazione dei prototipi è molto importante per una buona progettazione user centered. E’ fortemente sconsigliato pensare alle funzionalità che il prodotto dovrà fornire in questa fase della progettazione. E’ invece consigliato pensare a come l’utente deve interagire con il prodotto.

A questo punto si consiglia di seguire le norme dello standard ISO 9241 per la progettazione di interfacce usabili.

Innanzitutto bisogna tenere presenti le difficoltà che l’utente può affrontare nell’uso del prodotto.

Una rappresentazione semplicistica di come funziona la mente umana è stata resa disponibile da Norman nel 1986:

Il golfo della esecuzione è la differenza tra le intenzioni e le possibili azioni che si possono effettuare sul sistema.

Il golfo della valutazione è la quantità di sforzo necessaria ad interpretare lo stato fisico del sistema e determinare fino a che punti corrisponde alle aspettative.

Il nostro scopo è minimizzare i due golfi.

Secondo l’ISO 9241 l’usabilità di un prodotto è definita come il grado con cui può essere usato da specifici utenti per raggiungere specificati obiettivi con efficacia, efficienza e soddisfazione.

E’ quindi una definizione multidimensionale.

E’ necessario sviluppare un’interfaccia secondo i principi del dialogo dell’ISO 9241-110

Adeguatezza al compito: Un dialogo è adeguato al compito nella misura in cui supporta l’utente nell’efficace ed efficiente completamento del compito: dialogo essenziale, passi adeguati al compito, informazione adeguata al compito, formati di input adeguati al compito ed ecc...
Auto-Descrizione: Un dialogo è auto-descrittivo se agli utenti risulta evidente, in ogni momento, in che dialogo si trovano, a che punto si trovano all’interno del dialogo, quali azioni possono compiere e come queste possono essere eseguite.
- Guida all’utente (inf. Operative, Inf. Su stato del sistema, feedback)

- Interazione evidente (legato all'effordance)

- Manualistica minima

- Stato visibile (attende input? Elabora? Ha finito?)

- Descrizione dell’input atteso (legato al vincolo d'uso)

- Formati descritti

Conformità alle aspettative: Un dialogo è conforme alle aspettative se corrisponde alle necessità dell’utente, prevedibili in base al contesto e a convenzioni comunemente accettate.

Linguaggio familiare (molto importante: testo, icone,...)

Aderenza alle convenzioni (Dubai: lettura da destra a sinistra)

Organizzazione abituale

Dialogo consistente

Feedback conforme alle aspettative

Tempi di risposta conformi alle aspettative

Messaggi adeguati al contesto

Messaggi in posizione adeguata

Input in posizione attesa

Stile coerente dei messaggi

Adeguatezza all’apprendimento: Un dialogo è adeguato all’apprendimento se supporta e guida l’utente nell’apprendimento del sistema.

Bassa soglia di apprendimento

Aiuto alla familiarizzazione

Aiuto online

Feedback intermedio

Modello concettuale evidente (quale logica?)

Spermentazione sicura (undo nei sistemi)

Riapprendimento facilitato

Controllabilità: Un dialogo è controllabile se l’utente è in grado di iniziare e tenere sotto controllo la direzione e i tempi dell’interazione fino al raggiungimento dell’obiettivo.

Tempi di interazione controllati dall'utente (no time-out se non

necessari)

Proseguimento del dialogo controllato dall'utente

Punto di ripartenza controllato dall'utente

Reversibilità delle operazioni (undo)

Modalità di visualizzazione dei dati controllata dall'utente

Dispositivo di interazione scelto dall'utente

Personalizzazione dei valori di default

Disponibilità dei dati originali

Tolleranza verso l’errore: Un dialogo tollera gli errori se, nonostante evidenti errori negli input, i risultati desiderati possono essere ottenuti senza o con minime azioni correttive. La tolleranza per gli errori si ottiene attraverso

a) prevenzione;

b) segnalazione e

c)- azioni correttive automatiche

Assistenza all'utente

Verifica e convalida dei dati

Prevenzione di azioni non valide

Richieste di conferma

Spiegazione dell'errore

Spiegazione aggiuntiva

Assistenza per il recupero

Minimo sforzo di correzione

Correzione differibile

Correzione automatica modificabile

Adeguatezza all’individualizzazione: Un dialogo è adeguato all’individualizzazione se l’utente può modificare l’interazione e la presentazione dell’informazione per adattarle alle proprie necessità e capacità individuali.

Scelta di rappresentazioni alternative

Scelta del formato dei dati di input e output

Vocabolario personalizzabile

Scelta del livello delle spiegazioni

Personalizzazione dei tempi di risposta

Scelta del metodo di interazione

Personalizzazione del dialogo

Ripristinabilità dei valori precedenti

Ora bisogna pensare all’interfaccia tenendo presenti le precedenti norme per il corretto sviluppo di sistemi usabili.

Consiglio di sviluppare i prototipi dell’interfaccia in maniera low fidelity su carta, come degli schizzi di ogni interfaccia. Senza svilupparli nel dettaglio (cioè compresi di funzionalità), ma dare una struttura generale che consenta di simulare un minimo di interazione con il sistema.

Pianificazione e conduzione del test di usabilità con l’utente, applicazione dei test formativi

Qui si prepara il documento per la valutazione dell’usabilità delle interfaccie implementate sui prototipi.

Pianificazione:

1 – quali parti del sistema devono essere valutate?

2 – come devono essere valutate?

3 – quali prototipi saranno realizzati?

4 – come deve essere eseguita la valutazione? Con quali risorse?

5 – quali dovranno essere le interazioni con gli utenti?

6 – come dovrà essere condotta l'analisi dei risultati?

Istruzioni per lo svolgimento del test

L’utente inizia il test con le interfacce dei prototipi precedentemente sviluppati. Il progettista mostra le varie interfacce progettate a seconda di come interagisce l’utente con il sistema: cioè alla pressione di un tasto, mostra l’interfaccia collegata.

Viene chiesto ad ogni utente, in modo separato, di spiegare cosa vede nell’interfaccia; chiedere secondo loro cosa faccia ogni controllo e cosa ci farebbero loro con quel controllo. Da questo tiriamo fuori un modello concettuale per ogni utente, formato sulla propria esperienza pregressa e sulla sua interpretazione dei controlli che vede. In questo modo iniziamo a capire i punti errati e/o non sviluppati del sistema. Finita questa parte, si procede col prendere in considerazione il primo utente (da solo) e lo si sottopone agli esempi di task tipici, spiegando come sarà svolto il test vero e proprio, e chiedendo di pensare a voce alta, eseguendo i vari passi che sta facendo a voce alta e ragionando a voce alta (metodo del tink aloud) l’osservatore deve annotare tutto, ricordando, se l’utente non lo fa, di parlare e dire cosa fa o cosa pensa. Finita questa fase, si prende in considerazione anche l’utente 2 e insieme all’utente 1, lo si sottopone al terzo esempio di task (esempio di task numero 3), In questo caso si utilizza il metodo dell’interazione costruttiva, cioè il secondo utente testa in prima persona il sistema, affiancato dall’utente che l’ha testato precedentemente, eseguendo il task ricevuto. Durante i test i progettisti devono prendere appunti, e compileranno anche la modulistica relativa al raccoglimento delle varie misure. I valutatori non devono intervenire se non per ricordare agli utenti che devono pensare e ragionare a voce alta e per tranquillizzarli, così da diminuire la normale tensione da esame che potrebbe non far proseguire in modo corretto il test.

Si potrebbe anche far usare l’interfaccia un utente per volta, l’importante è videoregistrare cosa dice l’utente, cosa fa e come lo fa e quali difficoltà incontra.

Le misure da rilevare sono: il success rate (ovvero la percentuale di compiti risolti senza problemi) e il tempo impiegato per svolgere ogni compito impartito.

Queste misure ci danno una buona idea sulla reale usabilità del sistema da sviluppare.

Questi test, anche chiamati test formativi, servono a dare forma al progetto: infatti i progettisti capiscono i probabili difetti di interazione, modificano l’interfaccia (on the fly) del prototipo su carta anche facendosi aiutare dagli utenti stessi e poi continuano con la valutazione.

Durante il test con l’utente modificare l’interfaccia (test formativi):

I test formativi sono utilizzati durante il ciclo iterativo di progettazione, per sottoporre i vari prototipi a prove d’uso con gli utenti, allo scopo di identificarne i difetti e migliorarne l’usabilità. Si chiamano formativi perché, appunto, contribuiscono a “dare forma” al prodotto: il loro scopo è individuare il maggior numero possibile di problemi. Essi sono particolarmente utili nelle fasi iniziali della progettazione, quando il design concept è appena abbozzato.

Completare il test con un questionario da sottoporre agli utenti. Ecco alcune possibili domande:

Quale parte del sistema o quale caratteristica e/o funzionalità ritieni meno soddisfacenti? Perchè?
Quale parte del sito e/o funzionalità avrebbe bisogno di miglioramenti?
Cosa hai trovato confuso o frustrante con le opzioni di interfaccia utente?
Aggiungeresi qualche opzione o funzionalità? Se si, quale?
Che cosa potremmo fare per migliorare il prodotto?

Il rapporto di valutazione derivante dall’analisi dei documenti e delle registrazioni ci daranno un quadro completo di come modificare l’interfaccia.

Sviluppo del prodotto o servizio

Questa è la fase in cui il prodotto deve essere sviluppato il più fedelmente possibile con i prototipi modificati.

In questa fase si può pensare alle funzionalità ma MAI MODIFICARE LE INTERFACCE PER ADATTARLE ALLE FUNZIONALITA’ DEL PRODOTTO: sono le funzionalità che devono adattarsi alle interfacce e non viceversa.

Questa è la vera differenza tra la progettazione classica e la progettazione user centered.

Valutazione euristica e test sommativi

Jakob Nielsen

Per valutazione basata su euristiche si denota un procedimento non rigoroso che consente di prevedere o rendere plausibile un determinato risultato, che in un secondo tempo dovrà essere controllato e convalidato con metodi rigorosi. Nell’ingegneria dell’usabilità, si chiamano euristiche quelle valutazioni di usabilità effettuate da esperti, analizzando sistematicamente il comportamento di un sistema e verificandone la conformità a specifiche “regole d’oro” (chiamate, appunto, euristiche), derivanti da principi o linee guida generalmente accettati. In pratica, per eseguire una valutazione euristica, l’esperto di usabilità dovrebbe considerare una regola euristica alla volta, ed esaminare dettagliatamente le funzioni del sistema, per verificarne la conformità.

La valutazione euristica ha il vantaggio di essere relativamente poco costosa. Tuttavia fornisce risultati piuttosto soggettivi. Quanto più le euristiche sono generali, tanto più il risultato della valutazione dipenderà dall’esperienza, dalla sensibilità e, a volte, dalle preferenze personali del valutatore.

Un'euristica e' quindi una linea guida o un principio generale che puo' guidare l'attivita' di design o puo' essere usata per analizzare una scelta gia' fatta. La valutazione euristica, sviluppata da Nielsen e Molich, si avvale di un insieme di semplici e generali euristiche per valutare un sistema. L'idea generale e' che piu' valutatori analizzano indipendentemente il sistema, piu' problemi di usabilita' vengono individuati. Nielsen afferma che un numero ragionevole di valutatori e' tra 3 e 5 con un risultato finale del 75 % degli errori di usabilita' riconosciuti.

Nielsen raccomanda le seguenti 10 caratteristiche (Le 10 Euristiche di Nielsen oppure Il Decalogo di Nielsen):

Visibilità dello stato del sistema Il sistema dovrebbe sempre informare gli utenti su ciò che sta accadendo, mediante feedback appropriati in un tempo ragionevole.
Corrispondenza fra il mondo reale e il sistema. Il sistema dovrebbe parlare il linguaggio dell’utente, con parole, frasi e concetti familiari all’utente, piuttosto che termini orientati al sistema. Seguire le convenzioni del mondo reale, facendo apparire le informazioni secondo un ordine logico e naturale.
Libertà e controllo da parte degli utenti Gli utenti spesso selezionano delle funzioni del sistema per errore e hanno bisogno di una “uscita di emergenza” segnalat con chiarezza per uscire da uno stato non desiderato senza dover passare attraverso un lungo dialogo. Fornire all’utente le funzioni di undo e redo
Consistenza e standard Gli utenti non dovrebbero aver bisogno di chiedersi se parole, situazioni o azioni differenti hanno lo stesso significato. Seguire l convenzioni della piattaforma di calcolo utilizzata.
Prevenzione degli errori Ancora meglio di buoni messaggi di errore è un’attenta progettazione che eviti innanzitutto l’insorgere del problema. Eliminare le situazioni che possono provocare errori da parte dell’utente, e chiedergli conferma prima di eseguire le azioni richieste.
Riconoscere piuttosto che ricordare Minimizzare il ricorso alla memoria dell’utente, rendendo visibili gli oggetti, le azioni e le opzioni. L’utente non dovrebbe aver bisogno di ricordare delle informazioni, nel passare da una fase del dialogo a un’altra. Le istruzioni per l’uso del sistema dovrebbero essere visibili o facilmente recuperabili quando servono.
Flessibilità ed efficienza d’uso Acceleratori – invisibili all’utente novizio – posson spesso rendere veloce l’interazione dell’utente esperto, in modo che il sistema possa soddisfare sia l’utente esperto sia quello inesperto. Permettere all’utente di personalizzare le azioni frequenti.
Design minimalista ed estetico I dialoghi non dovrebbero contenere informazioni irrilevanti o necessarie solo di rado. Ogni informazione aggiuntiva in un dialogo compete con le unità di informazione rilevanti e diminuisce la loro visibilità relativa.
Aiutare gli utenti a riconoscere gli errori, diagnosticarli e correggerli. I messaggi di errore dovrebbero essere espressi in linguaggio semplice (senza codici), indicare il problema con precisione e suggerire una soluzione in modo costruttivo.
Guida e documentazione Anche se è preferibile che il sistema sia utilizzabile senza documentazione, può essere necessario fornire aiuto e documentazione. Ogni tale informazione dovrebbe essere facilmente raggiungibile, focalizzata sul compito dell’utente, e dovrebbe elencare i passi concreti da fare, senza essere troppo ampia.

Uso dei test sommativi:

I test sommativi indicano una valutazione più complessiva del prodotto, al di fuori – o al termine – del processo di progettazione e sviluppo. Sono test più completi di quelli formativi, che non hanno lo scopo di fornire indicazioni ai progettisti, ma di valutare in modo sistematico pregi e difetti del prodotto, o sue particolari caratteristiche. Sono di solito condotti quando il sistema è completamente funzionante, per esempio per indicarne i punti deboli e valutare l’opportunità di un redesign migliorativo. Oppure per confrontarne le caratteristiche con quelle di sistemi concorrenti.

Per effettuare un test sommativo, si analizza il sistema dal punto di vista della conformità agli standard ISO 9241 o ISO 13407 e si analizza il sistema analizzando la conformità alle euristiche precedentemente descritte.

I livelli di maturità di un prodotto sono:

1° livello: il prodotto funziona (fattibilità), risolve problemi di natura tecnologica; si ha un sistema rudimentale con funzioni base.
2° livello: il prodotto fornisce le funzionalità necessarie(fattibilità, prestazioni, flessibilità e alcune indagini di usabilità); livello del task-centered design, completezza e qualità delle funzioni.
3° livello: il prodotto è facile da usare (livello dell’user centered design)
4° livello: il prodotto è invisibile durante l’uso (funziona, è usabile e si integra perfettamente nelle attività dell’utente).

Conclusioni

L’user centred design è una tecnica che ha permesso di sviluppare sistemi usabili di grande successo come le interfacce utente degli iPhone, iPad (interessante visitare il sito http://www.andreapicchi.it/) oppure come quasi tutti i servizi Google infatti la stessa Google in un’intervista (questa) dice: “Key point stressed several times: User-centered design ; User-centered design means building products that people really want and start with users needs and desires for designing products and services.”

Google Search è infatti un’ottimo esempio di UCD invece Yahoo! Search lo è meno:

Anche prodotti Microsoft come Windows Phone sono il risultato di un notevole studio sull’user centered design.

A questo indirizzo c’è una guida (per i Manager) dal titolo “Selling the value of user centered design” che dimostra sia mediante percentuali (si parla di ROI return on investment) che di qualità del prodotto , il perché dell’importanza dell’uso dei processi di UCD durante le fasi di progettazione.

Buon UCD!

Domande frequenti

In che senso la progettazione human-centred è diversa dalla progettazione intesa in senso tradizionale (progettazione centrata sul sistema)?

La progettazione centrata sull’essere umano (human-centred design) è un approccio allo sviluppo dei sistemi interattivi specificamente orientato alla creazione di sistemi usabili. È un’attività multi-disciplinare che incorpora la conoscenza e le tecniche dei fattori umani e dell’ergonomia. L’applicazione dei fattori umani e dell’ergonomia alla progettazione dei sistemi interattivi ne potenzia l’efficacia e l’efficienza, migliora le condizioni del lavoro umano e contrasta i possibili effetti avversi dell’uso sulla salute, sulla sicurezza e sulle prestazioni. Applicare l’ergonomia alla progettazione dei sistemi richiede che si tenga conto delle capacità, delle abilità, delle limitazioni e delle necessità umane. I sistemi human-centred supportano gli utenti e li motivano a imparare. I benefici possono includere una maggiore produttività, una migliore qualità del lavoro, riduzione dei costi di supporto e di addestramento e una migliore soddisfazione dell’utente. Mentre la progettazione centrata sul sistema l’oggetto principale dell’attenzione è il sistema da progettare. Il processo di progettazione parte dalla definizione dei suoi requisiti funzionali, cioè dall’identificazione delle funzionalità (o delle funzioni) che esso deve fornire al suo utente, che vengono descritte in dettaglio in un documento di specifiche funzionali, a partire dal quale il sistema viene progettato e quindi realizzato. In questo approccio, l’utente del sistema ha un ruolo, tutto sommato, abbastanza marginale: il progettista concentra la sua attenzione sulle funzionalità, e sugli aspetti tecnici connessi alla loro realizzazione, per arrivare a soddisfare le specifiche con un rapporto costo/qualità accettabile.

Che cosa si intende per design pattern?

Si intende una soluzione generale a un problema di progettazione che si ripropone in molte situazioni, anche diverse fra loro. Non una soluzione “finita”, ma piuttosto un modello, un template da adattare allo specifico contesto.

Quali sono i principali standard prodotti dal Technical Committee 159/SC 4 dell’ISO?

I principali standard prodotti dal Technical Committee 159/SC4 dell’ISO sono:

- ISO 13407 (Human-centred design processes for interactive systems);

- ISO 9241 (Human-computer interaction), suddiviso in otto serie tematiche:

Serie 100: software ergonomics;
Serie 200: Human system interaction processes;
Serie 300: Displays and display related hardware;
Serie 400: Physical input devices - ergonomics principles;
Serie 500: Workplace ergonomics;
Serie 600: Environment ergonomics;
Serie 700: Application domains - Control rooms;
Serie 900: Tactile and haptic interactions.

- ISO 14915 (Software ergonomics for multimedia user-interfaces), composto da tre documenti:

Part 1: Design principles and framework;
Part 2: Multimedia navigation and control;
Part 3: Media selection and combination.

Oltre agli International Standard, l’ISO può produrre altri tipi di documenti, con un livello di consenso inferiore: ISO Technical Specification (ISO/TS), ISO Public Available Specification (ISO/PAS) e ISO Technical Report (ISO/TR). In particolare, il TC/159 SC 4 ha prodotto questi documenti aggiuntivi:

- ISO/TR 16982: Ergonomics of human-systems interaction – Usability methods supporting human-centred design;

- ISO/PAS 18152: Ergonomics of human-systems interaction – Specification for the process assessment of human-system issues;

- ISO/TR 18529: Human-centred lifecycle process descriptions.

Vincenzo Dentamaro

Software Engineer

MeCloud progetto Cloud computing

2011-11-09T14:12:00.008+01:00

MeCloud

Brings me to the cloud!

Introduzione

MeCloud è un'architettura Cloud SaaS (Software as a Service) che permette agli utenti di effettuare l'upload di documenti testuali nei formati txt, rtf e htm, permette di leggere ed editarli direttamente “online” ed inoltre permette di effettuare l'upload di immagini, di visualizzare le immagini caricate e di condividere con altri utenti di MeCloud le immagini e i documenti caricati.

Il servizio è totalmente gratuito e prevede altre features come la cerazione e la gestione di nuove applicazioni e l'inserimento di inserzioni pubblicitarie e script per il SEO (Search Engine Optimization) però queste funzioni (seppur previste nel Web Service) non sono state realizzate nel sito di testing come caso di studio per l'esame di Web.

Architettura per l'implementazione reale (business):

Questa soluzione prevede un server contenente apache e il sito in php, N server (virtuali) in cloud sparsi per il mondo ospitanti ognuno un Web Service MeCloud e X server SQL in replica tra loro (tutti contengono gli stessi dati) con X << N .

Il database di MeCloud prevede una soluzione che permette di gestire utenti diversi su diversi Web Service e addirittura documenti (file degli utenti) diversi su Web Services diversi.

Cioè se l'utente n1 effettua l'upload del file “xyz” tale file sarà caricato su un WebService scelto mediante una politica di random o performance. Così più file di ogni utente vengono caricati su diversi WebServices sparsi per il globo terrestre (the cloud).

Inoltre se altri utenti sono abilitati ad accedere a tali file, perché esplicitamente condivisi, questi potranno accederci senza problemi usando tutti i diversi Web Services necessari, tutto questo a totale insaputa dell'utente finale. In questo modo si realizza la relazione molti a molti (un grafo) tipica di un social network.... però di files e applicazioni online!

Questa architettura viene chiamata “Cloud Balancing” e solo poche aziende al mondo la possiedono (Google App Engine, Amazon EC2).

MeCloud Web Service

Il Web Service di MeCloud si divide in 2 sotto servizi:

Web Service SOAP per l'autenticazione e l'interscambio di informazioni da e verso il sito o un'applicazione esterna.
Web Service HTTP Request per la creazione di path virtuali verso i file e lo streaming del contenuto dei file attraverso HTTP.

Per evitare di dare l'accesso diretto (la full path) del file presente sul server al client, il Web Service, mediante il secondo sotto servizio, ad ogni richiesta crea una path virtuale verso il file e lo trasferisce al client mediante http. Tale path virtuale è data dal passaggio di parametri queli l'ID del file richiesto e il TokenID (cifrato con RSA a 1024 bit e codificato in base64) della sessione.

Per maggiori informazioni riguardo il sistema di cifratura usato fare riferimento alla sezione Sicurezza in MeCloud del presente documento.

La path virtuale verso un documento (o immagine) quindi sarà così modellata:

http://mecloud.us:8081/file?id=”idDelFile”&tk=”idCifratoEcodificatoDellaSessione”

Il parametro tk è il TokenID della sessione: ogni utente dopo aver effettuato il login ha un tokenid, tale stringa di 32 caratteri rappresenta l'utente all'interno del sistema. La stringa viene rigenerata a random ad ogni login ed è diversa per ogni utente.

Ho implementato un algoritmo di “collision prevent” per la generazione automatica di stringhe a 32 caratteri (vedere funzione RandomString di MeCloudService.asmx.cs).

Il web service soap MeCloudService utilizza il protocollo di comunicazione SOAP (Simple Object Access Protocol) versione 1.1 e 1.2 che si attiene alle specifiche REST dove:

Lo stato dell'applicazione e le funzionalità sono divisi in Risorse WEB

§ Ogni risorsa è unica e indirizzabile usando sintassi universale per uso nei link ipertestuali

§ Tutte le risorse sono condivise come interfaccia uniforme per il trasferimento di stato tra client e risorse, questo consiste in:

§ un insieme vincolato di operazioni ben definite

§ un insieme vincolato di contenuti, opzionalmente supportato da codice on demand

§ un protocollo che è:

§ Client-Server

§ Stateless

§ Cachable

§ A livelli

Il Web Service nonostante sia implementato in C# .NET gira su Linux Ubuntu 11.04 grazie al framework open source Mono che ne garantisce anche la portabilità su piattaforme Windows e Unix Like a 32 o 64 bit senza bisogno di ricompilare il tutto per la specifica architettura.

Lista dei metodi implementati in MeCloudService Web Service:

Operation / Method Name	SOAPAction*	Input Message	Output Message
Login	http://mecloud.us/Login	Input Msg	Output Msg
LostPassword	http://mecloud.us/LostPassword	Input Msg	Output Msg
ShareItem	http://mecloud.us/ShareItem	Input Msg	Output Msg
SendInvitations	http://mecloud.us/SendInvitations	Input Msg	Output Msg
DeleteItem	http://mecloud.us/DeleteItem	Input Msg	Output Msg
GetLinearizedListOfItems	http://mecloud.us/GetLinearizedListOfItems	Input Msg	Output Msg
Register	http://mecloud.us/Register	Input Msg	Output Msg
UploadFile	http://mecloud.us/UploadFile	Input Msg	Output Msg
AddApp	http://mecloud.us/AddApp	Input Msg	Output Msg
ShareApp	http://mecloud.us/ShareApp	Input Msg	Output Msg
RemoveAppAssociation	http://mecloud.us/RemoveAppAssociation	Input Msg	Output Msg
GetAppList	http://mecloud.us/GetAppList	Input Msg	Output Msg
StoreSettings	http://mecloud.us/StoreSettings	Input Msg	Output Msg
GetSettings	http://mecloud.us/GetSettings	Input Msg	Output Msg
GetUserInfo	http://mecloud.us/GetUserInfo	Input Msg	Output Msg

Il Metodo Login : Il Metodo di Login accetta 3 parametri in input:

Input Parameters

encryptedBase64Mail	string
encryptedBas64Password	string
encryptedBase64APIKey	string

Output Parameters

LoginResult

string

Tale metodo permette di autenticarsi nel sistema MeCloud.

Il sito invia i parametri (mail, password e API Key) cifrati con la chiave pubblica del sistema e codificati in base64. Il WS dopo aver decodificato da base64 a UTF-8 la stringa e dopo aver decriptato la stessa, effettua una query sul db per vedere se la API Key è presente, se il risultato è affermativo allora la procedura continua, altrimenti il WS ritorna un errore di “bad API Key”. Dopodiché si verifica la presenza della mail nel db e in caso affermativo si estrae la password e la si confronta con la password passata in input dal sito. Le password sono “case sensitive”. Se le password coincidono, il WS ritornerà in output il TokenID (generato automaticamente in questo istante e che ha la durata dell’intera sessione per poi essere rigenerato) della sessione ma non cifrato, in caso contrario un errore di “bad password”.

Il Metodo LostPassword: Accetta in input un solo parametro:

Input Parameters

encryptedBase64Mail

string

Questo metodo server a rinviare la password in caso di smarrimento.

Se la Mail cifrata e codificata è presente nel database, allora verrà estratta la relativa password e quest’ultima verrà inviata mediante una mail alla mailbox relativa. Se la password non è presente, nulla verrà inviato. Il metodo non restituisce alcun parametro (void).

Il Metodo ShareItem: Accetta 4 parametri in ingresso:

Input Parameters

base64EncryptedAPIKey	string
base64EncryptedToken	string
base64EncryptedOtherUserMail	string
ItemID	string

Output Parameters

ShareItemResult

string

Questo metodo permette di condividere un oggetto (immagine o documento) con più utenti.

Il metodo accetta in input 3 parametri cifrati e l’ItemID non cifrato.

Il sistema dopo aver decriptato e decodificato tutti i parametri in ingresso controlla la presenza dell’API Key, estrae l’ID dell’utente (colui che condivide il documento) dal TokenID della sessione e l’id del secondo utente, colui che subirà la condivisione dal parametro otherUserMail. Dopodiché associa nella tabella del database USERSTOITEM lo stesso item a più utenti (nel esempio solo 2), l’utente che ha subìto la condivisione dell’item riceverà una mail che lo informa dell’avvenuta condivisione.

Il Metodo SendInvitations: accetta un solo parametro in ingresso, cioè la mail di colui che riceverà l’invito. Esso serve per inviare inviti ad usare MeCloud a persone non ancora registrate. Non effettuerà alcun controllo.
Il Metodo DeleteItem: Serve a cancellare un item. Verrà cancellata sia la presenza fisica del file sul sistema di storage che tutte le referenze relative nel database.

Tale metodo accetta 3 parametri in input:

Input Parameters

base64EncryptedAPIKey	string
base64EncryptedToken	string
ItemID	string

Output Parameters

DeleteItemResult

string

Dopo aver decodificato e decriptato i dati in input (tranne ItemID il quale non è cifrato) viene controllata la presenza dell’API Key nel DB, viene estratto l’user id relativo al TokenID passato e viene verificata l’esistenza dell’associazione userid -> itemid nella tabella USERSTOITEM del database. In caso affermativo, l’eliminazione può avere atto:

viene cancellato l’item dalla tabella ITEM e dalla tabella USERSTOITEM e dopo viene cancellato il relativo file fisico dal sistema di storage.

§ Il Metodo GetLinearizedListOfItems: ha il compito di ritornare una lista linearizzata contenente gli items di ogni utente. Tale lista è una stringa dove ogni item diverso è separato dall’altro item mediante il simbolo “pipe” |. La stringa in output sarà così formattata: FileName1,MimeType1,ServerAddress1,ItemID1|FileName2,MimeType2,ServerAddress2,ItemName2|

Ho deciso di usare una lista linearizzata perché non è sempre vero che tutti i linguaggi di programmazione gestiscono array di stringhe serializzate su XML. Quindi, per compatibilità, ho deciso di linearizzare il tutto. Il quale verrà poi splittato in array di stringhe da chi invoca il WS.

Input Parameters

base64EncryptedAPIKey	string
base64EncryptedToken	string

Output Parameters

GetLinearizedListOfItemsResult

string

§ Il Metodo Register : permette di restrarsi al sistema

I parametri sono :

Input Parameters

encryptedBase64Mail	string
encryptedBas64Password	string
encryptedBase64RealName	string
encryptedBase64LastName	string

Output Parameters

RegisterResult	string

I parametri in input sono 4 però RealName e LastName sono facoltativi, infatti non vengono usati da MeCloud (sito) in PHP.

Il sistema restituisce una stringa contenente “ok” se la registrazione ha avuto successo, altrimenti riporta il tipo di errore (ad esempio “Already Registered”).

§ Il Metodo UploadFile: permette di caricare file sul cloud. I file devono avere dimensione inferiore a 25 MBytes e possono essere soltanto del tipo accettato dal web service, infatti esso controlla il MimeType del file prima della memorizzazione. I tipi supportati dal WS sono: PDF, JPG,PNG,GIF,TIFF,MP3,DOC,DOCX,TXT,RTF,PPT,XLS.

Input Parameters

encryptedBase64Token	string
encryptedBase64APIKey	string
data	base64Binary
encryptedBase64MimeType	string
encryptedBase64FileNameWithoutPath	string

Output Parameters

UploadFileResult

string

Tutti i parametri tranne l’array di bytes da trasferire sono codificati e criptati con RSA.

Una volta che i dati sono arrivati al WebService mediante SOAP, quest’ultimo controlla la dimensione dei bytes, i quali devono essere < 25Mbytes. Poi controlla la correttezza dell’API Key, recupera le informazioni riguardo l’utente mediante il TokenID, analizza il tipo mime ed è pronto per scrivere il file sullo storage.

Se ci sono alcuni problemi durante la scrittura, un’eccezione verrà sollevata e il file non verrà salvato e la procedura verrà chiusa automaticamente.

Se il file viene scritto senza problemi, verranno create dei reference all’interno delle tabelle ITEMS e USERSTOITEM, dove la tabella ITEMS conterrà tutte le informazioni riguardanti il file caricato, la tabella USERSTOITEM invece conterrà la relazione itemid -> userid.

§ Il Metodo GetUserInfo: è importante per l’integrazione API e l’interazione con altre applicazioni le quali vogliono recuperare informazioni riguardo l’utente. Per esempio Facebook o Google mettono a disposizione degli strumenti simili per “tirar fuori” informazioni riguardo l’utente. In questo caso MeCloud ritorna solo l’user id e la mail dell’utente. La password non uscirà mai dal sitema, potrà soltanto essere reinviata alla mail del associata per il recupero della stessa.

Input Parameters

encryptedBase64Token	string
encryptedBase64APIKey	string

Output Parameters

GetUserInfoResult

string

§ I Metodi AddApp, ShareApp, RemoveAppAssociation, GetAppList, StoreSettings, GetSettings sono REALMENTE implementati all’interno di Mecloud Service WS ma non sono stati implementati nel sito in php a causa della scarsità di tempo a disposizione.

Tali metodi permettono agli utenti di memorizzare delle proprie applicazioni (RIA) e linkarle all’interno del sistema MeCloud, dando l’opportunità all’utente di creare il proprio contenuto.

Sicurezza in MeCloud

In un Web Service di uso pubblico la sicurezza delle informazioni memorizzate è fondamentale.

Dalla letteratura informatica si evince che al momento gli algoritmi di cifratura più sicuri (il che significa non sicuri al 100%) sono gli algoritmi a chiave pubblica OTP (one time pad).

A causa dell'overhead causato dal continuo generare di chiavi per ogni richiesta scambiata tra il sito ed il Web Service (multi-tier architecture), non è consigliabile usare un sistema (per quanto matematicamente dimostrato come il più sicuro) one time pad. Per MeCloud ho deciso di cifrare con l'algoritmo RSA a 1024 bit solo alcune informazioni scambiate tra il Web Service e il sito in PHP. Per mantenere la compatibilità tra i due sistemi ho usato uno strumento di generazione chiavi molto conosciuto ed ultra testato : OpenSSL.

Con OpenSSL ho generato la chiave pubblica, privata, modulo e il certificato.

Tali file risiedono sia nella directory “certificates” del sito in php che nella directory “certificates” del web service MeCloud Service.

Come precendentemente descritto molti metodi del web service accettano in ingresso dei parametri cifrati, di solito sono l'API Key e il Token ID.

Abbiamo già parlato del TokenID, ma non dell' API Key. Ogni Web Service che si rispetti ha un APIKey (Google Map, Youtube, Facebook Web Service ed ecc...), questo ApiKey identifica l'applicazione che sta effettuando la chiamata al web service e quest'ultimo può applicare delle policy di sicurezza diverse per ogni applicazione che si interfaccia verso di esso: ad esempio l'API Key di un'applicazione per smartphone (Android ad esempio) sarà certamente diversa da quella del sito MeCloud o da un'applicazione desktop di MeCloud.

Per quanto riguarda la sicurezza, possono accedere a Mecloud Service WS solo gli API Key prememorizzati nel database, cioè solo le applicazioni autorizzate.

Questi parametri (API Key e TokenID) vengono cifrati (mediante la chiave pubblica) e codificati in base64 dal sito in php e poi inviati via SOAP al web service MeCloud Service, il quale provvederà a decodificarli e decriptarli mediante il binomio chiave pubblica e privata tipico di un sistema di cifratura asimmetrico .

Anche il Web Service HTTP (il secondo web service integrato in MeCloud) usa il sistema di decifraggio RSA per decriptare il TokenID dell'utente e creare la path virtuale verso il file, il quale viene inviato in streaming.

I dati binari trasferiti tra l'utente e il sito e tra il sito e il web service non sono cifrati. Cifrare tutti i dati “costerebbe” significativamente sulle performance fino a rendere il servizio inutilizzabile.

D'altro canto non è possibile tirar fuori i dati dal WS manualmente poiché il TokenID della sessione è sempre trasferito cifrato.

Ecco la funzione (php) di cifratura :

function encryptAndEncodeToBase64($data){

$server_public_key = openssl_pkey_get_public(file_get_contents("certificates/publickey.pem"));

openssl_public_encrypt($data, $encrypted, $server_public_key);

return base64_encode($encrypted);

}

Ecco la funzione di decriptaggio in c#:

Carico le chiavi e creo l'oggetto RSA che mi permetterà di effettuare il decriptaggio

if(myCert2 == null || rsa == null){

myCert2 = new X509Certificate2(certificatesPath+"mecloudprivatekey.pfx",privatePassw,X509KeyStorageFlags.MachineKeySet);

rsa = (RSACryptoServiceProvider)myCert2.PrivateKey;

}

e per decriptare :

byte[] decrpyted = rsa.Decrypt(Convert.FromBase64String(encryptedBas64Password), false);

String loginPwd = System.Text.Encoding.UTF8.GetString(decrpyted);

decrpyted = rsa.Decrypt(Convert.FromBase64String(encryptedBase64APIKey), false);

String ApiKey = System.Text.Encoding.UTF8.GetString(decrpyted);

Il database MySQL interno a MeCloud è protetto da password e non accetta connessioni in ingresso da host non autorizzati. In questo caso ho opportunamente modificato il file /etc/hosts facendo in modo che l'unico host autorizzato sia il loop back device, ovvero localhost (127.0.01).

MeCloud usa un sistema di passaggio di TokenID su url e mediante l’uso di cookie contenente il TokenID. Quando l’utente effettua il logout, il cookie relativo alla sessione viene cancellato (si imposta la scadenza ad un numero molto precedente) e l'utente è costretto ad effettuare nuovamente il login.

Interfacciamento tra PHP e MeCloudService Web Service

Invece di utilizzare direttamente la classe SoapClient messa a disposizione dagli sviluppatori di PHP, ho deciso di generarmi in automatico una classe wrapper chiamata MeCloudService.php che si occupa di invocare i metodi tramite SoapClient e ritornare i valori ricevuti dal web service.

Il tool usato si chiama WSDLInterpreter e genera in automatico la classe PHP mediante l'analisi del WSDL di Mecloud Web Service.

Il protocollo usato per l'interscambio di informazioni è SOAP. Soap permette di trasferire “buste” XML contenenti dati serializzati. XML è anche usato in altri protocolli come XML-RPC ed ecc...

Avrei potuto usare Json invece di XML risparmiando banda e tempo di trasferimento dei dati, ma a discapito della compatibilità.

In futuro MeCloud sarà implementato mediante chiamate asincrone (tipo Ajax) e scambi di dati tra il broswer, il lato server del sito e il Web Service.

A titolo informativo, sono in corso alcune polemiche riguardo l'uso di Ajax browser side... si pensa che l'uso abbondante di questa tecnologia nelle pagine dinamiche sia fonte di exploit (fondamentalmente Cross Site Scripting e Denial Of Service) andando contro la sicurezza degli utenti, dei loro dati e del servizio offerto. Per questo motivo si stanno implementando nuovi protocolli come WebSocket. Sto quindi pensando di implementare MeCloud con chiamate SOAP asincrone lato server per poi portare in “superficie” solo il risultato senza invocare il Web Service esterno direttamente da javascript (browser side).

Cioè login e password vengono inviate “Server side” e ciò che il Web Service ritorna viene prima elaborato dal lato server del sito e poi portato in superficie rendendolo disponibile ai controlli in javascript.

Esempio di invocazione del Web Service MeCloudService con PHP

Per l’invocazione del WS di MeCloud via PHP ho generato la classe MeCloudService.php.

L’uso è il seguente:

Innanzitutto bisogna includere tale classe nel sorgente con questa istruzione:

require_once("MeCloudService.php");

Qui di seguito ci sono le istruzioni per invocare il web service. Nell’esempio recupererò l’userid e la mail dell’utente invocando il metodo GetUserInfo del web service.

$mecloud = new MeCloudService();

$parameters = new GetUserInfo();

$parameters->encryptedBase64Token = encryptAndEncodeToBase64($TokenID);

$parameters->encryptedBase64APIKey = encryptAndEncodeToBase64("FLJQPZTXOEXWOJGLXZLMDPSEQPOQWYXO");

$response = $mecloud->GetUserInfo($parameters)->GetUserInfoResult;

//la variabile $response contiene il valore: userid,mail

//ora divido (split) la stringa in 2 paramtri userid e mail

$temp = explode(",",$response);

$userid = $temp[0];

$mail = $temp[1];

Il Database di MeCloud

Per migliorare le performance ho ridotto al minimo l'uso di join e ogni selezione è fatta basandosi unicamente dagli ID dei vari elementi. Addirittura la tabella con più elementi è la tabella USERSTO ITEM la quale ha solo due campi rappresentati dagli ID. Le performance, nonostante le basse capacità della macchina virtuale, sono abbastanza soddisfacenti.

Il progetto è scaricabile da qui: MeCloud.zip - 1.2 MB
Il software è rilasciato gratuitamente per l'utilizzo, ma non può essere modificato ne integralmente ne in parte. Dal software in questione non possono essere copiati pezzi di codice o risorse varie.
Scaricando il software si accettano le suddette condizioni d'uso.

(c) 2011 by Vincenzo Dentamaro

Leggimi TTS Engine (Text To Speech) Sapi 5.1

2011-11-09T13:27:00.002+01:00

Leggimi TTS SR è un programma scritto da me nel 2006/2007 per il dettato, il riconoscimento vocale e l'esecuzione di comandi vocali su un pc Windows.
Usa le SAPI (Speech Application Programming Interfaces) di Windows in versione 5.1.
E' gratuiro e pienamente configurabile.

Ho voluto reinserirlo perché la mia vecchia pagina su Xoomer è andata perduta.

Quindi guardate qui cosa avevo inventato 5 anni fa.
Ecco il link per scaricarlo

GridTask Project: Java, PHP, JavaScript developer needed

2010-12-22T10:41:00.005+01:00

GridTask

Update october/03/2011

Here is the link to the sources http://gridtask.googlecode.com/files/GridTask.zip

-------------------------------------------------------------------------------------------------------------

GridTask is a Open Source Grid Computing System project.
"Grid computing combines computers from multiple administrative domains to reach common goal to solve a single task and may then disappear just as quickly" as Wikipedia says.

GridTask is a OpenSource software solution that will allow research centers or private to upload a job written in java (respecting few simple programming rules) that will run on this distributed infrastructure.

In grid systems, each client which receive the job to compute is called Node.
In GridTask each node is a certified applet that will run directly from a web page, the bytecode executed from the applet should be certified by Oracle.
The applet can be inserted in sites like Wikipedia and more, which would allows people to draw scientific informations and also tacitly collaborate in scientific research providing a small slice of their CPU time ("computation") to solve computational problems joining in an "ACTIVE WAY" for research.
The infrastructure is composed by a Server Broker which is a server that registers Nodes and project's Resource Brokers.
Resource Brokers are distributed resource schedulers able to choose at which node assign the computation. Each uploaded project has its Resource Broker which run inside the remote site of gridtask.org and managed internally by GridTask System.
GridTask infrastructure should be completely written in Java using Oracle JDK or OpenJDK respecting Java6SE standards and RMI Remote Method Invocation for more infos about this click here.
For NAT traversal and fast p2p interaction we should use JXSE and JXTA2 or uPNP Lib for RMI which enables uPnP Standards NAT traversal to realize this high-performance, massively scalable distributed computing over p2p network.

About the site:
GridTask site (domain to buy) will allow people to register and have their applet HTML code (the applet with USERID code) to insert in sites, also will allow to control the incoming traffic and read statisics about the jobs received.
The site with the great number of visitors for day will receive different premiums and advertising on GridTask site.
The GridTask site should provide to research centers to upload jobs, write informations about the uploaded job (job documentation) and attend the job to be validated (to avoid security issues) by Eliggible GridTask Security Commission. Each job to compute will have a webpage under GridTask domain wich will allow to see the computational progress and statistics.

This is our opportunity to achieve something of concrete and free (free as OpenSource and free as free of charge) to help scientific research even in countries like Italy where scientific research is at the bottom place in the list....

How to join GridTask project:

JAVA, PHP, JavaScript programmers needed:

Please if you are a java, php, javascript developer and you want to participate the GridTask Porject, please send me an email or visit this site:

http://code.google.com/p/gridtask/

Thanks

Vincenzo Dentamaro, IT Professional Developer.

Grid Computing in Java (English Version)

2010-10-12T11:03:00.004+02:00

Purpose of the article:
This article aims to show how can be structured the architecture of a distributed computing, for purposes such as scientific research (such as distributed computing of segments of DNA for fetal disease analysis or cancer research and so on ...) .
It is not needed special hardware or software and even so many years of java programming, although I must admit that the distributed programming and RMI (Remote Method Invocation) belong to the topics covered in the "Advanced Programming", however, in my opinion , it is a possible challenge.
Good reading.

What is Grid Computing ?

Grid computing or grid systems are distributed computing infrastructure used for processing large amounts of data through the use of a vast amount of resources. In particular, these systems allow the coordinated sharing of resources within a virtual organization.

How is it possible to implement this kind of architecture in Java using standard computer in a "home made" way?

We're going to pitch in one of the most important pioneering topics about the research in the field of networks and Internet.

To create a globally extended grid computing system , we need a Java Virtual Machine (not tested with OpenJDK), an operating system that supports Java (Mac OSX, Linux, Windows, Solaris, and etc ...) in particular there need java6 and a computer with a good amount of RAM (1 GB), an IDE for Java programming (Eclipse is recommended) and last (but certainly not least) a lot of patience ....

The distributed architecture, very simplistic, that I am going to show in this article consists of a central node, that we call Server, which provides a naming service (Name Server) to query the various nodes of the network and also plays as Resource Broker (distributed resource scheduler able to choose at which node assign the calculation), all other nodes (computer network) are called clients of the central server, but since they provide the service of calculation, so we can not think of an architecture Grid as a simple Client / Server Architecture, but to something closer to a hybrid Peer to Peer.

Each node receives a task (job) to be completed in a time T, this time must be greater than the transferring time necessary to transfer the data parameters to the distributed method at the maximum speed that the network supports, ie Telab > (Data * Frequency) otherwise is not convenient using a system like Grid Computing.

How to realize it using Java

Needed classes:

DistributedServer Interface
DistributedServerSystemImpl Class which is the implementation of the DistributedServer interface
ResourceBroker Class
ResourceBrokerServerName Class

In the example is shown the procedure to compress, crypt, uncompress and decrypt atoms of a file using RSA at 1024 bit and LZMA compression algorithm. It is, basically, the piece of the prototype of the distributed implementation for the SPTP (Secure Parallel Distributed Transfer Protocol) which I invented about one year ago.

DistributedServer Interface

This interface has two methods: CreateDataPackage and unpackData which deal with compress or decompress encrypt and decrypt atoms respectively usingLZMA and RSA algorithms, these methods can be replaced by the methods of calculation you want to distribute. In java, you can also pass as parameter everything that is serializable.Serializable tasks are seen in the official Oracle example.

package SPTP.protocol.GridComputing;

import java.rmi.Remote;

import java.rmi.RemoteException;

import java.security.KeyPair;

import java.security.PublicKey;

import SPTP.protocol.CommonClasses.*;

public interface DistributedServer extends Remote {

      public PackageStream createDataPackage(byte[] dataToSend,int packageID,

                  Compression.compressionType type, PublicKey key,

                  final int ATOMIC_SIZE, ListOfPackagePOJO listOfPackage,

                  String NUM_OF_THREADS) throws RemoteException;

      public byte[] unpackData(PackageStream pkg, int packageID, KeyPair keys,

                  int packageSize, Compression.compressionType type)

      throws RemoteException;

      /**

      * Greater is the value returned, more possibility it has to be chosen by

      * the Resource Broker when compared with other nodes.

      * @return value of free available processors and resources (greater is   better)

      * @throws RemoteException

      */

      public int getWorkload() throws RemoteException;

      public boolean youLive() throws RemoteException;

}

DistributedServerSystemImpl Class
This class is not only the physical implementation of the interface DistributedServer but rather is the implementation of the node, indeed as the software that must run on one of the many computers client. Specifically, pay attention to the implementation of the Main.
In the Main, the client tries to log into the server (whose IP address is passed as the main parameter) then once logged in, it creates a registry of distributed objects that musts process and waits for the incoming calls from the server. To close the node the user must type "exit" on a console.
The example refers to few external classes, developed by me, you can found these classes in the SPTP package found at this address.

package SPTP.protocol.GridComputing;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.DataOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.net.InetAddress;

import java.net.Socket;

import java.net.UnknownHostException;

import java.rmi.Naming;

import java.rmi.RemoteException;

import java.rmi.RMISecurityManager;

import java.rmi.server.UnicastRemoteObject;

import java.rmi.registry.*;

import java.security.KeyPair;

import java.security.PublicKey;

import java.util.ArrayList;

import SPTP.protocol.CommonClasses.Compression;

import SPTP.protocol.CommonClasses.ListOfPackagePOJO;

import SPTP.protocol.CommonClasses.PackageStream;

import SPTP.protocol.CommonClasses.RSA2;

import SPTP.protocol.CommonClasses.Utility;

import SPTP.protocol.CommonClasses.Compression.compressionType;

public class DistributedServerSystemImpl extends UnicastRemoteObject

implements DistributedServer{

                  /**

                  * SERIAL VERSION ID

                  */

                  private static final long serialVersionUID = 7165234451015536983L;

                  private int workload ;

                  private int numOfProcessors;

                  String nodeName = "Node";

                  public DistributedServerSystemImpl() throws RemoteException

                  {

                                    super();

                                    this.numOfProcessors = Runtime.getRuntime().availableProcessors();

                  }

                  public DistributedServerSystemImpl(String nodeName) throws RemoteException

                  {

                                    super();

                                    this.numOfProcessors = Runtime.getRuntime().availableProcessors();

                                    this.nodeName = nodeName;

                  }

                  @Override

                  public PackageStream createDataPackage(byte[] dataToSend, int packageID,

                                                      compressionType type, PublicKey key, int ATOMIC_SIZE,

                                                      ListOfPackagePOJO listOfPackage, String NUM_OF_THREADS)

                  throws RemoteException {

                                    System.out.println("I am ready to create data package");

                                    this.numOfProcessors--;

                                    byte[] data2 = Compression.compress(dataToSend, type);

                                    dataToSend = data2;

                                    int numOfAtoms = Utility.getPackagesNumber(dataToSend.length, ATOMIC_SIZE);

                                    ArrayList<byte[]> list = new ArrayList();

                                    int lastSector = 0;

                                    byte[] arrayTemp;

                                    for(int i = 1; i <= numOfAtoms; i++ ){

                                                      if(i == numOfAtoms){



                                                                        int newSector = lastSector + 1;

                                                                        arrayTemp = new byte[((dataToSend.length) - lastSector )];

                                                                        int n = 0;

                                                                        for(int j = lastSector; j < dataToSend.length; j++){

                                                                                          arrayTemp[n] = dataToSend[j];

                                                                                          n++;

                                                                        }

                                                                        try {

                                                                                          list.add(RSA2.encrypt(arrayTemp, key));

                                                                        } catch (Exception e) {

                                                                                          e.printStackTrace();

                                                                        }

                                                      }else{

                                                                        arrayTemp = new byte[ATOMIC_SIZE];

                                                                        int m = 0;

                                                                        while(lastSector < ((ATOMIC_SIZE) * i)){

                                                                                          arrayTemp[m] = dataToSend[lastSector];

                                                                                          lastSector++;

                                                                                          m++;

                                                                        }



                                                                        try {

                                                                                          list.add(RSA2.encrypt(arrayTemp, key));

                                                                        } catch (Exception e) {

                                                                                          // TODO Auto-generated catch block

                                                                                          e.printStackTrace();

                                                                        }

                                                      }

                                    }

                                    PackageStream pack = new PackageStream(list,packageID);

                                    this.numOfProcessors++;

                                    return pack;

                  }

                  @Override

                  public byte[] unpackData(PackageStream pkg, int packageID, KeyPair keys, int packageSize,

                                                      compressionType type) throws RemoteException {

                                    System.out.println("I am ready to unpack data!");

                                    this.numOfProcessors--;

                                    byte[] arrayTemp = new byte[0];

                                    try{

                                                      ArrayList lista = new ArrayList();

                                                      ArrayList data = pkg.getData();

                                                      byte[] temp = new byte[0];

                                                      for(int i = 0; i < data.size(); i++){

                                                                        try {

                                                                                          byte[] unCifred = RSA2.decrypt((byte[])data.get(i),keys);

                                                                                          temp = arrayTemp.clone();

                                                                                          arrayTemp = new byte[unCifred.length+temp.length];

                                                                                          int posAttuale = 0;

                                                                                          for(int h = 0; h < (temp.length) && temp.length > 0; h++){

                                                                                                            arrayTemp[h] = temp[h];

                                                                                                            posAttuale = h;

                                                                                          }

                                                                                          int m = 0;

                                                                                          if (i == 0) posAttuale = -1;

                                                                                          for(int h = posAttuale + 1; h < (unCifred.length+temp.length);h++ ){

                                                                                                            arrayTemp[h] = unCifred[m];

                                                                                                            m++;

                                                                                          }



                                                                        } catch (Exception e) {

                                                                                          // TODO Auto-generated catch block

                                                                                          e.printStackTrace();

                                                                        }

                                                      }

                                    }catch (Exception e) {

                                                      System.err.println("An error occurred:"+e.toString());

                                    }

                                    byte[] toReturn = Compression.uncompress(arrayTemp, type);

                                    this.numOfProcessors++;

                                    return toReturn;

                  }

                  public int getWorkload() throws RemoteException{

                                    float m = Runtime.getRuntime().totalMemory()/

                                    Runtime.getRuntime().freeMemory();

                                    this.workload = Math.round(m * this.numOfProcessors);

                                    return this.workload;

                  }

                  public boolean youLive() throws RemoteException{

                                    System.out.println("Yes I am live");

                                    return true;

                  }

                  public static void main(String args[]) throws IOException {

                                    InetAddress localHost = null;

                                    try {

                                                      localHost = InetAddress.getLocalHost();

                                    } catch (UnknownHostException e2) {

                                                      // TODO Auto-generated catch block

                                                      e2.printStackTrace();

                                    }

                                    if(args.length > 0){

                                                      String toSend = localHost.getHostAddress();

                                                      String received;

                                                      Socket clientSocket = null;

                                                      System.out.println("Trying to connect to "+args[0].toLowerCase()+"...");

                                                      do {

                                                                        try {

                                                                                          clientSocket = new Socket(args[0].toLowerCase(), 12999);

                                                                                          ObjectOutputStream outToServer = new ObjectOutputStream(clientSocket.getOutputStream());

                                                                                          outToServer.writeObject(toSend);

                                                                                          outToServer.flush();

                                                                                          ObjectInputStream inFromServer = new ObjectInputStream(clientSocket.getInputStream());

                                                                                          received = (String) inFromServer.readObject();

                                                                                          System.out.println("FROM SERVER: " + received);

                                                                                          clientSocket.close();

                                                                        } catch (Exception e) {

                                                                        }

                                                      } while (clientSocket == null);

                                    }

                                    System.setSecurityManager(new RMISecurityManager());

                                    try {

                                                      LocateRegistry.createRegistry(1099);

                                                      System.out.println("Registry created");

                                                      DistributedServer ds = new DistributedServerSystemImpl(localHost.getHostAddress());

                                                      Naming.rebind("//"+localHost.getHostAddress()+"/Node", ds);

                                                      System.out.println("Node on "+localHost.getHostAddress()+" is ready");

                                                      BufferedReader dis = new BufferedReader(new InputStreamReader(System.in));

                                                      while (!"exit".equals(dis.readLine())) ;

                                                      UnicastRemoteObject.unexportObject(ds, false);

                                    } catch (Exception ex) {

                                                      ex.printStackTrace();

                                    }

                  }

}

ResourceBroker Class

Resource Broker is responsible for installing a log on the server machine in which to reference and keep track of all nodes connected to it and also it keeps track to whom node entrust the job and also to it is responsable of removing nodes that are no longer used or which are currently inaccessible.
Choosing the best node to send a piece of work is done automatically: the Resource Broker asks each node in the list how many free resources it has (the value corresponding to free resources is the ratio between the total memory and the free memory multiplied by the number of available processors). Then by a simple (and linear) algorithm to choose the maximum, is chosen the node that statistically has more available resources.
This is only a prototype, the ResourceBroker can be greatly optimized implementing search algorithms with computational complexity at most O(n log N), or implementing more precise search criteria based on the physical distance between the server and the client (in meters) .

package SPTP.protocol.GridComputing;

import java.io.IOException;

import java.net.InetAddress;

import java.net.MalformedURLException;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.UnknownHostException;

import java.rmi.AccessException;

import java.rmi.Naming;

import java.rmi.NotBoundException;

import java.rmi.RMISecurityManager;

import java.rmi.RemoteException;

import java.rmi.registry.LocateRegistry;

import java.rmi.registry.Registry;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import SPTP.protocol.ServerInterface.ConnectionHandler;

public class ResourceBroker implements Runnable {

private ArrayList nodeList ;

private DistributedServer preferredNode;

private boolean enabled = true;

public ResourceBroker() throws RemoteException, UnknownHostException {

nodeList = new ArrayList();

System.out.println("RMI server started");

// Create and install a security manager

if (System.getSecurityManager() == null) {

System.setSecurityManager(new RMISecurityManager());

System.out.println("Security manager installed.");

}

else

System.out.println("Security manager already exists.");

try //special exception handler for registry creation

{

LocateRegistry.createRegistry(1099);

System.out.println("java RMI registry created.");

} catch (RemoteException e) {

System.out.println("java RMI registry already exists.");

}

Thread t = new Thread(this);

t.start();

}

@Override

public void run() {

InetAddress localHost = null;

try {

localHost = InetAddress.getLocalHost();

} catch (UnknownHostException e2) {

// TODO Auto-generated catch block

e2.printStackTrace();

}

Registry registry = null;

DistributedServer Node = null;

try {

registry = LocateRegistry.getRegistry(localHost.getHostAddress());

} catch (RemoteException e1) {

e1.printStackTrace();

}

try {

Node = new DistributedServerSystemImpl(localHost.getHostAddress());

} catch (RemoteException e1) {

e1.printStackTrace();

}

try {

Naming.rebind("//"+localHost.getHostAddress()+"/Node", Node);

} catch (AccessException e1) {

System.out.println("AccessException launched");

e1.printStackTrace();

} catch (RemoteException e1) {

System.out.println("Remote Exception launched");

e1.printStackTrace();

} catch (MalformedURLException e) {

e.printStackTrace();

}

synchronized (nodeList) {

nodeList.add(localHost.getHostAddress());

}

this.preferredNode = (DistributedServerSystemImpl) Node;

System.out.println("PeerServer bound in registry");

PollingNodes pollingThread = new PollingNodes(8000, "Polling Nodes begun");

ServerSocket welcomeSocket = null;

try {

welcomeSocket = new ServerSocket(12999);

ResourceBrokerServerName resName =

new ResourceBrokerServerName(this,welcomeSocket);

System.out.println("Nameserver started!");

} catch (IOException e) {

e.printStackTrace();

}

while(enabled){

try {

this.preferredNode = searchBest();

} catch (MalformedURLException e1) {

e1.printStackTrace();

} catch (RemoteException e1) {

e1.printStackTrace();

} catch (NotBoundException e1) {

e1.printStackTrace();

}catch (NullPointerException e1) {

System.out.println("Empty List");

}

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

private DistributedServer searchBest() throws MalformedURLException, RemoteException, NotBoundException{

DistributedServer Node = this.preferredNode;

String toReturn = "";

if(nodeList.size() > 0){

String ip = nodeList.get(0);

toReturn = ip;

Node = (DistributedServer) Naming.lookup("rmi://"+

ip+"/Node");

for(int i = 0; i < nodeList.size(); i++){

ip = nodeList.get(i);

DistributedServer Node2 = (DistributedServer) Naming.lookup("rmi://"+

ip+"/Node");

if(Node.getWorkload() < Node2.getWorkload()) toReturn = ip;

}

Node = (DistributedServer) Naming.lookup("rmi://"+

toReturn+"/Node");

}

System.out.println("Best noode is "+toReturn+" \nWork Load: "+Node.getWorkload());

return Node ;

}

private void sort() {

synchronized (nodeList) {

Collections.sort(nodeList);

}

//other methods here

public void addNode(String IPNodeAddress){

addNode(IPNodeAddress,1099);

}

public void addNode(String IPNodeAddress,int Port){

try

{

synchronized (nodeList) {

nodeList.add(IPNodeAddress);

}

System.out.println("PeerServer bound in registry");

}catch (Exception e)

{

e.printStackTrace();

}

System.out.println("Number of nodes = "+nodeList.size());

}

public void deleteNode(String IPNodeAddress) throws

RemoteException, MalformedURLException, NotBoundException{

deleteNode(IPNodeAddress,1099);

}

public void deleteNode(String IPNodeAddress, int Port) throws

RemoteException, MalformedURLException, NotBoundException{

Naming.unbind("//"+IPNodeAddress+":"+Port+"/Node");

synchronized (nodeList) {

int h = -1;

for(int i = 0; i < nodeList.size(); i++){

if(nodeList.get(i).equals(IPNodeAddress)){

h = i;

}

if(h > -1) nodeList.remove(h);

}

public void shutdownGrid(){

this.enabled = false;

}

public DistributedServer getPreferredNode(){

return this.preferredNode;

}

class PollingNodes extends Thread {

private int delay;

private String message;

public PollingNodes(int delay, String msg) {

this.delay = delay;

message = msg;

setDaemon(true);

start();

}

public void run() {

String IP = "";

while(true){

if(nodeList.size() > 0){

for(int i = 0; i < nodeList.size(); i++){

DistributedServer Node = null;

synchronized (nodeList) {

IP = nodeList.get(i);

try {

Node = (DistributedServer) Naming.lookup("rmi://"+IP+"/Node");

} catch (MalformedURLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (RemoteException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NotBoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

try {

if(Node.youLive()) System.out.println("Node "+IP+" is live");

} catch (RemoteException e) {

try {

deleteNode(IP);

} catch (RemoteException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

} catch (MalformedURLException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

} catch (NotBoundException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

}

try {

Thread.sleep(this.delay);

} catch (InterruptedException e) {

e.printStackTrace();

}

ResourceBrokerServerName Class

This class takes care of accept automatically requests of authentication from the nodes and map the presence of authenticated nodes in the principal server.

package SPTP.protocol.GridComputing;

import java.net.*;

import java.io.*;

public class ResourceBrokerServerName extends Thread {

private ResourceBroker scheduler = null;

private ServerSocket welcomeSocket ;

public ResourceBrokerServerName(ResourceBroker scheduler,ServerSocket welcomeSocket) {

super();

this.scheduler = scheduler;

this.welcomeSocket = welcomeSocket;

Thread t = new Thread(this);

t.start();

}

public void run() {

while(true)

{

Socket connectionSocket = null;

try {

connectionSocket = this.welcomeSocket.accept();

new HandleRequest(connectionSocket);

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

public class HandleRequest extends Thread{

private Socket connection;

public HandleRequest(Socket connection){

this.connection = connection;

Thread t = new Thread(this);

t.start();

}

public void run(){

System.out.println("Richiesta avvenuta");

String clientSentence = "";

String capitalizedSentence = "";

ObjectInputStream inFromClient = null;

try {

inFromClient = new ObjectInputStream(connection.getInputStream());

} catch (IOException e2) {

// TODO Auto-generated catch block

e2.printStackTrace();

}

ObjectOutputStream outToClient = null;

try {

outToClient = new ObjectOutputStream(connection.getOutputStream());

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

try {

clientSentence = (String) inFromClient.readObject();

} catch (IOException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

} catch (ClassNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

scheduler.addNode(clientSentence);

System.out.println("Received: " + clientSentence);

capitalizedSentence = "Inserted";

try {

outToClient.writeObject(capitalizedSentence);

outToClient.flush();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

Launch our Grid Computing enviroment

Create the file java.policy for activate all the remothe invocation permissions:

grant {
permission java.security.AllPermission;
};

To use the developed classes, we must change the classes previously implemented so that they can invoke the distributed methods CreateDataPackage and unpackData, and each node also needs to be run using the command:

java -Djava.security.policy=java.policy -jar SPTP_DistrNode.jar 192.168.1.100

where 192.168.1.100 è is the IP server.
Once the server is active, the node will authenticate automatically.

In the package SPTP_DistrNode.jar is exported as executable class the DistributedServerSystemImpl class and it contains also all the other classes.

Final Author's toughts

This is only a prototype of distributed computing, in the example shown does not need any super computer system and even expensive IBM grid-style computing.
You just need the cooperation of the entire scientific community, a similar protocol could be implemented in sites like Wikipedia, which would draw on scientific information and also tacitly collaborate in scientific research providing a small slice of our calculation to solve computational problems joining in an "ACTIVE WAY" for research.

The European community will allocate 25 million Euros for the development of the EGI (European Grid Infrastructure), I think that can be saved all this money by implementing an architecture similar to one presented in this article using even the obsolete computer products since 2001 on . In this way we would solve two problems in one fell swoop: Grid Computing for Scientific Research and the problem of pollution from the disposal of obsolete computers.
Forgive the formatting errors indicating a bad indentation, but it's just the fault of the restricted space for the post on the blog.

Future revisions of this article are provided.

Vincenzo Dentamaro IT Professional Developer - University of Bari - Italy

Setup a Linux Server in only 5 minutes with Virtual Box and Lubuntu Linux Server 10.04 with GUI

2010-09-20T14:43:00.004+02:00

Setup a Linux Server in only 5 minutes !!

Do you want to setup a Linux Server but without buy a real Server or without buy Windows Server license or without partitioning and installing a linux server from scratch ?

Now there is the solution!

Just buy and use Virtual Box Lubuntu 10.04 Server Image for only 4,99 USD!

I will now explain you how to do it:

Go to http://www.virtualbox.org/wiki/Downloads and download for free VirtualBox for your operating system.
Install VirtualBox
Buy Lubuntu 10.04 Server with GUI from here , you will be redirected to a page where you can download it directly.
Unpack the package (in 7zip format) using this password: 064049f378843e3325cc83f73d1d9b9b
Open VirtualBox and create a new machine (just clicking on “New”)
In the “Name” field put “Lubuntu 10.04 Server with GUI” and click next.
Set over 512 Mb of ram for that system and click next.
In the “booting disk” field select “Use existing boot disk” and browse the already unpacked file "Lubuntu.vdi" .
Clck on END.
Click on RUN . And your Linux Virtual Server starts.

Screenshoot about Lubuntu 10.04 and Active Directory

Screenshoot about Webmin in Lubuntu Server 10.04

Lubuntu Server 10.04 LAMP/Tomcat Webmin Active Directory specifications:

Lubuntu stands for Lightweight Ubuntu Server.

This VirtualBox hdd server image has a simple and lightweight XFCE or LXDELAMPT (Linux/Apache/MySQL/PHP/Perl/Python/Tomcat) server with a preconfigured LDAPWebmin for the remote access (remote server management tool), OpenSSH (Secure Shell), Samba to manage Windows Networks and Likewise-Open that is a GUI to manage Active Directories (LDAP) with Linux. (Lightweight Direcotry Access Protocol) for manage active directories, it has GUI (graphical user interface) and it is a preconfigured

Pre-Installed Lubuntu Server configured for LAMP and Tomcat Java Servlets

* Apache

* mySQL Server

* PHP

* Java Servlets

* OpenSSH

* Samba

* Webmin

* Likewise Open (with GUI)

Super Simple to use!!

Profile Tips:

Configure the new Virtual Device in VirtualBox with Bridged Network configuration before starting VM

Once the computer boots. Login in as "adminuser" with the password "adminuser"

At the prompt enter the following command at the prompt

adminuser@lubuntu-10>ifconfig

Notice that the IP Adress in the eth0 "inet addr:" is part of the local network, the same address range as you Host computer.

In the following examples replace {ipaddr} with the result of the ifconfig command from the previous step.

You now have access Webmin Server Administrator tool:

Open a web browser on you host computer to;

https://{ipaddr}:10000

With webmin you will be able manage the Ubuntu server from using a web browser on your Host computer.

Access the topcat server at;

http://{ipaddr}:8080

Apache WWW Server

https://{ipaddr}:80

Versions:

Tomcat Server Version Information:

Server version: Apache Tomcat/6.0.24

Server built: September 20 2010

Server number: ...0

OS Name: Linux

OS Version: 2.6.32-21-generic

Architecture: i386

JVM Version: 1.6.0_18-b18

JVM Vendor: Sun Microsystems Inc.

VDI Information

Build Notes:

mySQL Server login information

username: root

password: adminuser

VirtualBox Settings

VirtualBox Version:

3.1.6

OS Type:

Lubuntu

Base Memory:

512

ACPI:

enabled

IO APCI:

enabled

username/password: adminuser/adminuser

Root Password: adminuser

Richard Stallman and the Free Software in Foggia Italy

2010-05-21T11:48:00.004+02:00

Richard Stallman and the Free Software in Foggia Italy

On 05/17/2010 Mr. Richard Matthew Stallman was in Foggia for the first time in a high school
whose name is "Liceo Classico Vincenzo Lanza".
But maybe someone doesn't know who is that man, well Mr. Stallman is an American software freedom activist and computer programmer (as wikipedia says), he is the father of GNU Project
and the father of the free software movements and the founder of the Free Software Foundation. Stallman pioneered the concept of copyleft and he is the main author of several copyleft licenses including the GNU General Public License, the most widely used free software license.

In the conference he spoke primarily about Free Software, the GNU Project and also talked about why the proprietary software is dangerous.

Before start analyzing these concepts I would like to focus on the figure of Mr. Stallman.
In my opinion Mr. Stallman is a person with a large magnetic personality, able to move the masses and who has a remarkable humility hardly observable in the dry modern society.
I could not believe to my eyes, Mr Stallman was there and I have also shook my hand with.

But, why is Mr. Stallman so mcuh important (not only to me) for the whole IT world?

For reply to this question I have to speak about Free Software and what I learned yesterday from him.

History of Free Software

The philosophy of free software was born in 1971 at MIT in a community that loved to exchange software and programming source code snippets from their writings, so that anyone could make changes to these programs in order to further improve and redistribute it.
This software was called free software (free as livre which doesn't stand for without costs but stands for freedom, in Italy we have an appropriate word to define it… Gratis means without costs and Libero means free …. as freedom )
At that time, the term Free Software did not exist. Then in the '80s, the community broke up because of the emergence of new operating systems with proprietary licenses, which made it difficult for free trade in software.
In 1983, Richard Matthew Stallman founded the GNU Project and the Free Software Foundation, whose aim was to produce a Unix-compatible, which is completely free and freely distributable. Although not fully developed, the project at the kernel level called Hurd software (produced by GNU) was of such great quality that System administrators often replaced the original programs of their distributions of Unix with GNU versions .
Despite that, the company chose to protect their interests and likely to play against the philosophy of free exchange of codes without restrictions.

What are the differences between proprietary and free software?

The social conception that proprietary software (which is the system requiring that software can not be shared or modified) is antisocial, unethical, and wrong may appear surprising.
In fact, people usually take for granted the definition of proprietary software. Software manufacturers have worked long and hard to convince people that there is only one way of looking at it.
When vendors talk about "enforcing their rights" or "stopping piracy", what they say is actually secondary. The real message of these statements is in the unstated assumptions (listed below) which they take for granted, being that they want that them to be accepted uncritically.

These assumptions are:

--The software companies have the unquestionable natural right of ownership on their software,
and therefore have control over all its users. If this were a natural right, we could not raise
objections, regardless of the damage that may cause others. Interestingly, the United States,
both the Constitution and legal tradition reject this view, copyright is not a natural right, but a
government-imposed monopoly that limits the users' natural right to make copies.

--The only important thing about software is what jobs it allows you to do, which is to say that we
(as users) should not care what kind of society we are allowed to live.

--We would not have usable software (or rather, that we could never have a program to do this or
that particular job) if we did not offer to the company the power over the users of the program.
This assumption may have seemed plausible but before that free software movement
demonstrated that we can make plenty of useful software without putting chains (or handcuffs as
Stallman often says).

If we refuse to accept these assumptions, and judge these issues based on common criteria of morality and common sense after you put first the interests of users, taking into account that users are first of all, we come to very different conclusions. Computer users should be free to modify programs to fit their needs, and be free to share software, because helping others is the foundation of society. This is the philosophy of free software.

What is Free Software instead?

A program is free software for a particular user, if:

* You have the freedom to run the program for any purpose (FREEDOM 1);
* You have the freedom to modify the program to suit your needs (because this freedom effective
in practice, you must have access to program source code, since making changes to a program
without having the source code is extremely difficult) (FREEDOM 2);
* The user has the freedom to redistribute copies, either gratis or for a fee (FREEDOM 3);
* You have the freedom to distribute modified versions of the program, so that the community can
benefit from improvements (FREEDOM 4).

Since "free" refers to freedom, not price, selling copies of a program does not contradict the concept of free software.

Another problem of proprietary software is that there may be malicious software features
which could control the installed software in the computer from remote, or install additional software without the user knowing it (the automatic update).
It is like software entering from the backdoor instead of entering from the front door.
The problem is that proprietary software is seen like a black box so we don't know what they are doing while they are in execution.
Stallman also said:
“I don't say that in all proprietary software there are malicious features, some of them have this problem, others not”.

Differences between Free Software and Open Source

Sometimes Free software is confused with Open Source, which is basically another thing since there are differences in terms of ethics, history and licenses.
I will analyze only the license differences because in my opinion, they are more important.

Regarding free software, the used license is the GNU Public License (GPL). This license was created by Stallman himself; it seeks to respect the principles set out above, by introducing a copy left to guarantee them.
The term copy left means that after processing the mechanism by which free software is forbidden to redistribute it as proprietary software, you must report the changes made to the author of the software. Later, it was clear that not all developers were satisfied by this license by writing the LGPL in 1991. The LGPL allows you to insert codes in free software or in proprietary software, without affecting the final license of the software. But these licenses limit the public domain (the ability to sell changes to free software).

For this reason, new licenses were created like the BSD License (Berkley Software Distribution license), which is most diffuse in Apple world, and the MPL (Mozilla Public License) from Mozilla foundation.

Today, the term Open Source is more popular than free software.
Just remember that one of the largest companies worldwide, like Sun Microsystems (now Oracle), prefers to use open source .
There are two reasons why:
--In English-speaking areas, the concept of freedom can be expressed only with the word Free. The
word also means without costs. This confusion seems counter-productive for some companies;

--In every movement, there have always been some schism, and Free Software does not seem to
be an exception (but I hope that it does not happen).

What is the GNU Project

"In the image GNOME desktop environment!"
As Stallman said, GNU stands for GNU and not Unix. Whoever has not studied a bit of theoretical computer science will not see anything exciting in all this. In the GNU word is a hidden recursion, seen by the computer programmers as a divine programming technique…in fact, it was once said, “Iterate is human, use recursion is divine!” (L. Peter Deutsch)…but I am deviating a bit from the context of the article, I am sorry.
GNU is a set of software developed under the GPL license, which is the usable part of the most known operating system called Linux. We don't create mistakes we HAVE to call it GNU/Linux, because what the user uses is the GNU software, Linux is only the Kernel (i.e. the internal core which does the hardware abstraction and which handles processes).
Personally, I love GNU/Linux…in fact, in my computer, I have ONLY GNU/Linux.

Most known GNU software are GNOME, GNASH, EMACS, BASH and many more...
Concerning BASH, last year I developed a parser for BASH in JavaCC whose name is jBash and is published under the GPL3 public license and used in a project for the European community .

The question I posed to Stallman

How can a student, with a passion for computing, transform that passion into a real job while earning money from free software?
You can hear his answer in this video:

My personal conclusions:

Free software in public administration, schools and other public institutions in all the world, should be applied because the savings would be significant.
Personally, the answer Stallman gave to my question, did not convinced me, not for the motivations, which are noble and important, but because I imagine the difficult future for designers and developers of free software, as me, in a world where everything has a price.
It is not enough to live only by the maintenance of a free software or from its assistance.
As a student worker, I wish that this passion would turn into something profitable but in the right measure. The work for the glory is often superficial and eventually ends before arriving at a good stage of the project because of less money.
It is true that the policy of Free Software is based on the exchange of source, so someone else can continue my pioneering work, but it is also true that behind a proposed Free Software, there is not always a good basis for analysis and design…many developers of free software (as I did) have spent more time in writing the source code than in designing. This approach requires much maintenance and software costs increases exponentially (as a principle of software engineering) and software quality decrease just as rapidly.
In conclusion, Free Software is good for little/medium software without much complexity or for very big software such as software for humanity (GNU/Linux) because it should be tested and modified by a large number of people (remembering that in free software the end user is the real beta tester).
I must admit that all software, even most important, have to made available with the source code (fees may be applied and should be assigned all rights about recognition of creativity to their respective owners) to prevent major social problems such as monopoly and malicious software features.

Vincenzo Dentamaro

Thanks to:
Nicole Marquez for the corrections made.
Flavio Tisi for Stallman contact.

SFS Technology - It's a solution to make portable programs and improve Linux software sharing -

2010-02-05T14:30:00.002+01:00

SFS Technology

It's a solution to make portable programs and improve Linux software sharing

The new sfs technology solves software dependencies and installation problems. It consists of a unique file that can be mounted as a normal file-system with all really needed libraries and files of the specific program. When mounted the sfslauncher will start the application stored into it. The procedure is completely transparent to the end user; Just double click on the "program.sfs" and sfslauncher will do the magic. Starting with version 1.0 we improved the integration: the operating system now knows the "sfs" file type as a native executable file.

How does it work?

(See the video, download link is at bottom of document) Well, the file "program.sfs" is a squashfs compressed file that can be used as a virtual file system. The .sfs file can be mounted by a daemon in a hidden directory (/.mounted/"SFSprocessID"). Once mounted the file, sfslauncher program will read the executable's name and all the parameters stored into the "parameters" file (a simple text file). Then the sfslauncher will read the description.id file and will execute the executable file. When the user will close the executable (the software into the package) sfslauncher call the daemon and send to him a command called "flush": the daemon will release the thread, unmount the .sfs file and delete the hidden directory.

What is NOT contained in the sfs file ?

The Desktop environment's libraries and other operating system's native libraries as for example KDE libraries, gtk+2, glib, libc6 and many more.

What will contain the .sfs file ?

The sfs file contains just the most necessary libraries to perform a correct software execution.

These are what we think are the highlight of the SFS Technology:

1--Ease of use;

2--Ease of software sharing;

3--The base configuration of the operating system remains unaltered;

4--It allows dynamic library linking;

5--It allows using different version of software;

6--The sfs technology preserve the environment: it work in USER MODE;

7--Operates also in 64 Bit environment;

8--Released under the GNU/GPL license;

9--A version for Linux Mobile (ARM processors) is under development

10-- Can run simultaneously max 256 sfs application!!

This project is under develop at page

http://code.google.com/p/sfs-technology/

UbuntuItalian? forum discussion : http://forum.ubuntu-it.org/index.php?topic=283698.0

NEW VERSION 1.1.0.4 :

--Automatically Dependency Handling:

This new version allows handling dynamically some dependencies that could not be in a SFS package. If defined, sfslauncher will try to install this not founded dependency by a simple graphical user interface, showing a popup message!

--This new version allows Nautilus to associate the icon contained into the SFS executable file to the correspondent SFS , having the same effect as the executables files do on Windows or Macintosh, where each has its own icon.

--Make Portable Option: This new option allows you to save the configurations of applications in the same folder where resides the SFS executable file. This directory could be situated on a portable device (like a USB pen) or on a normal root's directory.

This option is not enabled by default.

--SFS Editor: an editor for the SFS Technology Executable files downloadable from (for i386 and amd64 architectures): http://code.google.com/p/sfs-technology/downloads/list

--Some relevant bugs fixed

Video that show the SFS Technology at work !:

http://sfs-technology.googlecode.com/files/SFS_example_video.ogv

Image of some SFS programs:

SFS programs make links in the Main menu under Applications-->Other:

SFS Settings :

For more information about SFS Technology please contact me. This solution is very important to further increase the usability of Linux worldwide.

Vincenzo Dentamaro vincenzodentamaro@hotmail.com SFS Technology developer.

Technology published under Ubuntu Brainstorm :

License

This software is GPL v3 compatible

Frequently Asked Questions

Can two SFS executables share their resources?

The sfs packages contains only some libraries not provided in a standard Ubuntu installation, for example in a SFS package there will never be gtk+ libraries or system libraries, but only those libraries which that particular program needs to run properly and the library that are not in a normal Linux installation.Furthermore the static and dynamic linking between libraries is guaranteed, because the SFS load the GUI libraries and other important libraries from the standards shared directories (/usr/lib/ for example), rather less common libraries are loaded from the library directory contained in the SFS package, SFS also allow a system for the Dynamic Library Linking, I try to explain with an example how it works:I take 2 programs (programA.sfs and programB.sfs) both containing the same library called libraryX1.so. If the libraryX1.so is contained in the package programA.sfs when we launch the programA.sfs it will be loaded into memory, when we run the prgamB.sfs it will first seek the libraryX1.so into the mounted directory of programmA.sfs and if found this searched library, then do not load back into memory the same library, but will focus on the library already present in RAM, thus saving time of loading and space RAM.So in conclusion, unlike other technologies SFS Technology provides an interaction and a dynamic link between the libraries, does not contain standard libraries already present in a common installation of Ubuntu, is not a replacement for apt, it began as an aid to making using the software easier on Linux.The motto of Ubuntu is "LINUX for Human Beings"; well I think that the SFS Technology is a solution very close to the "Human Beings".

Thanks toNicole Monique Angelynn Marquez for the corrections made.

PROJECT LINK:

http://code.google.com/p/sfs-technology/

JBash - Java parser that accepts a sintax similar to BASH -

2010-02-04T18:08:00.002+01:00

Jbash is a parser that accepts a syntax similar to bash.

The main idea is to create a pseudo-shell that runs on any kind of device, from a smartphone to a normal pc.

Jbash can execute built-in commands and external program, export variables, evaluate expressions using a dynamic scope.

jBash is wrote using JavaCC so there is a javacc code implementation. It's released under the GNU GPL license.

(in the image you can see jBash running in a UNIX shell, but whereas it's wrote in Java so it can runs on any O.S. and architecture).

Links about jBash project:

http://code.google.com/p/jbash/

https://javatools.dev.java.net/newsletter/2009/20090806.html