Il Web 2.0

RSS è un‘applicazione per agevolare la distribuzione di contenuti attraverso il web, ottimizzando tempi e risorse. RSS è uno dei più popolari formati: in pratica rappresenta lo standard de facto ed è basato su XML.

Introduzione

Nello scorso articolo si è parlato in generale di Web 2.0 [MOKAWEB2_I], si è parlato poi del Wiki come un‘importante strumento Web 2.0 [MOKAWEB2_II] introducendo poi le tecnologie Web 2.0 come Ajax [MOKAWEB2_III].

In questo articolo ci concentreremo su RSS.

Cos‘è RSS

RSS è un‘applicazione XML, introdotta originariamente da Netscape nel tentativo di agevolare la distribuzione di contenuti attraverso il web (ottimizzando tempi e risorse). RSS è uno dei più popolari formati (in pratica rappresenta lo standard de facto) per la distribuzione di contenuti Web ed è basato su XML.

La continua produzione e revisione di informazioni recuperabili in Internet comporta un aumento dei tempi di consultazione, si pensi, ad esempio, alla necessità  che un utente ha di verificare la presenza di aggiornamenti e/o informazioni nei vari siti di interesse. Collegarsi al sito, attenderne l‘apertura, navigarlo alla ricerca delle novità  nella speranza che nel frattempo non sia cambiata l‘interfaccia utente, che non subentrino problemi di connessione, etc. Queste operazioni possono essere risparmiate in presenza di uno strumento (aggregatore) che ci avvisa automaticamente della presenza di nuovi contenuti da più fonti.

RSS è un formato standard per l‘esportazione di contenuti e rappresenta il linguaggio di comunicazione tra la fonte e l‘aggregatore.

Le sue successive variazioni sono state adottate progressivamente dalla comunità  dei "blogger" per il post o il recupero dei blog. La popolarità  dei blog è forse una delle ragioni principali del successo di RSS: migliaia di Weblog iniziarono a produrre contenuti in RSS e iniziarono a proliferare siti che raccoglievano una selezione di post dai blog più seguiti (i cosiddetti blog aggregator) e programmi per fruire i contenuti di un blog direttamente sul proprio desktop o su altri dispositivi (RSS reader).


Figura 1 - Stack RSS

Ã? molto interessante notare come, durante la sua evoluzione, l‘acronimo RSS abbia assunto ben tre diversi significati. Li analizziamo qui di seguito.

RSS come RDF Site Summary

Il primo significato assunto dall‘RSS è RDF Site Summary: la prima versione ufficialmente denominata RSS era in realtà  una semplificazione di una struttura basata sulle specifiche RDF. Struttura in seguito ripresa e attualmente mantenuta nel formato RSS 1.0 [RSS-1.0].
Parlando di RDF Site Summary si fa riferimento all‘RSS 0.9 [RSS-0.9] o alla sua naturale evoluzione sviluppata dall‘RSS-DEV Working Group secondo le specifiche RDF [W3CRDF]. Di seguito si riporta un esempio RSS 1.0:


xmlns="http://purl.org/rss/1.0/"
xmlns:content="http://purl.org/rss/1.0/modules/content/"
xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/"
xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
xmlns:dc="http://purl.org/dc/elements/1.1/">


Il Web 2.0
http://www.mokabyte.it/
RSS che controlla le uscite sull‘argomento Web 2.0







Alessandro Rocca
IT


II parte: Wiki
http://www.mokabyte.it/wiki
Articolo sullo strumento Wiki


III parte: Ajax
http://www.mokabyte.it/Ajax
Articolo sulle tecniche Ajax


IV parte: RSS
http://www.mokabyte.it/RSS
Articolo sulle specifiche RSS

RSS come Rich Site Summary

Per contrastare la complessità  derivante dall‘uso dell‘RDF, Dave Winer rilasciò il 10 luglio del 1999 una nuova versione di RSS. Si trattava dell‘RSS 0.91 [RSS-0.91], una versione semplificata delle specifiche 0.9 e soprattutto arricchita di nuovi tag.
Dal momento che l‘RSS 0.91 presentava una struttura completamente priva di qualsiasi riferimento all‘RDF, Dave Winer decise di rimuovere i riferimenti a RDF e di dare un nuovo nome a questo formato chiamandolo appunto Rich Site Summary.

Di seguito si riporta un esempio RSS 0.91:




Il Web 2.0
http://www.mokabyte.it/
RSS che controlla le uscite sull‘argomento Web 2.0
IT

II parte: Wiki
http://www.mokabyte.it/wiki
Articolo sullo strumento Wiki


III parte: Ajax
http://www.mokabyte.it/Ajax
Articolo sulle tecniche Ajax


IV parte: RSS
http://www.mokabyte.it/RSS
Articolo sulle specifiche RSS


RSS come Really Simple Syndication

Questo significato si riferisce all‘ultimo dei formati RSS pubblicati, ovvero l‘RSS 2.0 [RSS-2.0] rilasciato nuovamente da Dave Winer. Questo termine ("syndication" proviene dal gergo giornalistico e dei media, e si riferiva inizialmente alla distribuzione coordinata di informazione da parte di catene di quotidiani) è stato coniato per sottolineare la semplicità  d‘uso che contraddistingue questa versione, in contrasto con la precedente 1.0 rilasciata qualche mese prima dall‘RSS-DEV Working Group.

Di seguito si riporta un esempio RSS 2.0:


xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:dc="http://purl.org/dc/elements/1.1/" version="2.0">

Il Web 2.0
http://www.mokabyte.it/
RSS che controlla le uscite sull‘argomento Web 2.0
IT
Alessandro Rocca
IT

II parte: Wiki
http://www.mokabyte.it/wiki
Articolo sullo strumento Wiki
http://www.mokabyte.it/wiki


III parte: Ajax
http://www.mokabyte.it/Ajax
Articolo sulle tecniche Ajax
http://www.mokabyte.it/Ajax


IV parte: RSS
http://www.mokabyte.it/RSS
Articolo sulle specifiche RSS
http://www.mokabyte.it/RSS




Mentre con i primi due acronimi ci si riferisce al sommario di una singola fonte di informazioni, con il terzo si vuole puntare a dare una visione più globale di raccolta delle informazioni, introducendo il concetto di "canale" (syndication) attraverso il quale accedere al flusso (feed) di news proprio come si farebbe con una radio o una TV.

Nonostante le differenti implementazioni delle diverse versioni, i documenti RSS condividono tutti la stessa struttura di base, che prevede:

  • un elemento , che contiene le informazioni sulla fonte dei contenuti (nel caso di un quotidiano online potrebbe contenere il nome della testata, la data di pubblicazione, informazioni sul copyright, etc.);
  • una serie di elementi , ognuno dei quali corrisponde ad un singolo elemento di contenuto (p.e. l‘articolo di un giornale) e ne presenta tutte le informazioni (titolo, testo completo, nome dell‘autore, ecc.).

Dei vari formati esistenti, la versione 2.0, per la sua semplicità  di utilizzo, è attualmente il formato RSS più diffuso.

ATOM

Atom, come i vari formati RSS, è un implementazione XML per la sottoscrizione di contenuti web, come blog o testate giornalistiche. Ã? basato sull‘esperienza delle varie versioni del protocollo lanciato da Netscape, RSS. La specifica completata di Atom è stata presentata, nel giugno 2005, alla IETF per l‘approvazione: l‘ultimo passo per diventare uno standard internet RFC. Benchè la diffusione del formato RSS 2.0 sia nettamente superiore anche sul piano dello sviluppo rispetto ad Atom, la versione 1.0 di quest ultimo si sta affermando come standard nonchà© potenziale antagonista di RSS 2.0

Di seguito si riporta un esempio Atom 1.0:


xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
xmlns:dc="http://purl.org/dc/elements/1.1/">
Il Web 2.0

RSS che controlla le uscite sull‘argomento Web 2.0
Alessandro Rocca
IT

II parte: Wiki




Articolo sullo strumento Wiki


III parte: Ajax




Articolo sulle tecniche Ajax


IV parte: RSS




Articolo sulle specifiche RSS


Modalità  di fruizione di un RSS

I flussi (feed) Rss rappresentano dunque il metodo ideale per la notifica degli aggiornamenti dei contenuti, soprattutto in presenza di più fonti/canali (syndication).

Mentre una volta (il cosidetto Web 1.0) questa funzionalità  veniva fatta "a mano" aggiungendo tutti gli indirizzi di interesse tra i preferiti per poi navigarli periodicamente, ora (Web 2.0) il tutto viene fatto "in automatico".

Un feed reader è un programma in grado di effettuare il download di un feed RSS (è sufficiente che l‘utente indichi al programma l‘URL del feed), effettuarne il parsing e visualizzarne i contenuti in base alle preferenze dell‘utente.

Spesso i feed reader sono dotati di funzionalità  avanzate; ad esempio sono in grado di rilevare automaticamente se il produttore del feed ha effettuato aggiornamenti al feed stesso, effettuandone il download a intervalli di tempo regolari. In questo modo l‘utente può essere informato quasi in tempo reale quando un sito è stato aggiornato. [WPRSS]

Un generico feed RSS, proveniente da un sito, può essere facilmente importato da un altro sito Web, per incorporarne i contenuti all‘interno delle proprie pagine. Questa modalità  di fruizione è possibile mediante un web aggregator.

In seguito all‘aumento di popolarità  del formato RSS e alla sua standardizzazione, sono nati diversi servizi online che fungono da web aggregator.

Il vantaggio per l‘utente è notevole, poichà© ha la possibilità  di accedere a tutte le notizie attraverso un unico sito Web (web aggregator), evitando dunque di dover visitare, uno per uno, i siti da cui provengono le notizie stesse (magari solo per scoprire che non ci sono stati aggiornamenti dopo la sua ultima visita).

Tali aggregatori vengono distinti in base alla modalità  con cui si accede al feed. Le due categorie standard di aggregatori sono i web aggregator (o online aggregator) accessibili via web e i desktop aggregator, applicazioni stand alone che risiedono sulla macchina dell‘utente. L‘obiettivo di entrambi è quello di fornire un unico punto d‘accesso a notizie provenienti da varie fonti.

Esempi di web aggregator sono OKNotizie [OKNotizie], Digg [Digg], Bloglines [Bloglines] per la promozione di propri contenuti Bloglines.

Figura 2 - Esempio di web aggregator: OKNotizie di Alice

Un esempio di feed reader stand alone è FeedReader, programma free (distribuito con licenza GNU GPL) per piattaforme Microsoft Windows [MFEEDRD].

Una volta installato, basta avviarlo che subito si ottengono dei feed da tutta la rete potendo successivamente aggiungerne o toglierne a secondo dei propri specifici interessi.

Figura 3 - Esempio di feed reader stand alone

Occorre ricordare che un feed RSS è in formato XML per cui l‘elaborazione da parte di un qualunque aggregatore deve prevedere un‘operazione di parsing, ovvero una scansione del documento che individui i tag e isoli i diversi elementi, per poi convertire i contenuti decodificati nel formato utile all‘obiettivo: ad esempio un feed reader può estrarre i titoli di tutti gli elementi item per visualizzare la lista degli articoli di un giornale online, mentre un aggregatore Web può estrarre i contenuti del feed per convertirli in linguaggio HTML e incorporarli all‘interno delle proprie pagine.

I browser di ultima generazione (Firefox 2.0 e anche Internet Explorer 7.0) incorporano già  la funzionalità  di Feed Reader. Ad esempio, nella versione 2.0 di Firefox, è presente un aggregatore integrato e il suo segnalibri raccoglie in automatico i feed RSS come se fossero dei link già  memorizzati. L‘utente potrà  scegliere se salvarli o meno. Una volta connessi ad un sito che offre uno o più canali RSS o Atom, Firefox mostra vicino alla barra degli indirizzi la classica icona di notifica.

Figura 4 - RSS in Firefox

Selezionando l‘icona si viene indirizzati alla nuova pagina intermedia di gestione dei feed, dove è presente una descrizione del canale. A questo punto l‘utente ha la possibilità  di iscriversi al feed scegliendo una tra le opzioni disponibili.
Generalmente i browser riconoscono la presenza di feed RSS all‘interno di una pagina nel caso in cui sia stato inserito all‘interno della pagina stessa un tag link cosଠdefinito:

Figura 5 - Esempio di feed reader di IE 7.0

Alla luce di quanto detto si può evincere quanto sia semplice l‘utilizzo degli RSS considerando anche che sono estensibili e versatili e aggiornabili in tempo reale e quindi consentono ad esempio di metterne in tempi brevissimi i contenuti su un portale o su un weblog. Credo che per il responsabile di un sito (content manager) o per chi si occupa di comunicazione in Rete siano diventati indispensabili proprio per la loro praticità  d‘uso e per i molteplici campi di applicazione.

Rome: RSS in Java!

Ci sono diversi prodotti open source che permettono la creazione di RSS. Ad esempio Rome [ROME] è una libreria Java open source(sotto licenza Apache) che permette di gestire i documenti RSS nelle sue verie versioni (2.0, 1.9 e 0.9x) oltre ad Atom.

Rome include un insieme di parser e generatori per i vari formati RSS, oltre a convertitori da un formato all‘altro. Rome si basa su un modello astratto di News Feed o Syndication Feed. Su tale modello si basano le varie operazioni di generazione, lettura e conversione di feed nei vari formati. Tali operazioni si appoggiano su vari componenti quali parser XML SAX e DOM, jdom.

Lo schema seguente mostra le fasi di elaborazione di un feed RSS:

Figura 6 - Funzionamento di Rome [HRW]

Rome rappresenta un feed (RSS ed Atom) come oggetto di tipo com.sun.syndication.synd.SyndFeed. L‘interfaccia SyndFeed e le relative proprietà  seguono il modello JavaBean. Le implementazioni di default fornite da Rome sono tutti codici categoria leggeri.
Generare un feed tramite un SyndFeed bean consiste nel‘istanziare tale bean per poi impostarne le proprietà . Il codice seguente mostre un esempio sull‘utilizzo di tale oggetto.

Viene creata un‘istanza di tipo SyndFeed, specificando il tipo di feed (versione RSS o Atom), il titolo, il link e la descrizione:

SyndFeed feed = new SyndFeedImpl();
feed.setFeedType(feedType);

feed.setTitle("Sample Feed (created with Rome)");
feed.setLink("http://rome.dev.java.net");
feed.setDescription("This feed has been created using Rome (Java syndication utilities");

Viene predisposta la lista delle entry (item).

List entries = new ArrayList();
SyndEntry entry;
SyndContent description;

Vengono create le varie entry, per poi essere inserite nella lista precedente. Per ogni entry vengono specificati il titolo, il link, la data di pubblicazione e la descrizione.

entry = new SyndEntryImpl();
entry.setTitle("Rome v1.0");
entry.setLink("http://wiki.java.net/bin/view/Javawsxml/Rome01");
entry.setPublishedDate(DATE_PARSER.parse("2004-06-08"));
description = new SyndContentImpl();
description.setType("text/plain");
description.setValue("Initial release of Rome");
entry.setDescription(description);
entries.add(entry);
...
entry = new SyndEntryImpl();
entry.setTitle("Rome v3.0");
entry.setLink("http://wiki.java.net/bin/view/Javawsxml/Rome03");
entry.setPublishedDate(DATE_PARSER.parse("2004-07-27"));
description = new SyndContentImpl();
description.setType("text/html");
description.setValue("

More Bug fixes, more API changes,
some new features and some Unit testing

"+
"

For details check the ="http://wiki.java.net/bin/view/Javawsxml/RomeChangesLog
#RomeV03">Changes Log

");
entry.setDescription(description);
entries.add(entry);

feed.setEntries(entries);

A questo punto l‘oggetto SyndFeed è pronto per essere scritto come documento XML.
Attraverso l‘oggetto SyndFeedOutput, viene creato un output stream da agganciare a un oggetto Writer e procedere alla scrittura del documento XML:

SyndFeed feed = ...;
Writer writer = ...;

SyndFeedOutput output = new SyndFeedOutput();
output.output(feed,writer);

Figura 7 - Esempio di RSS 2.0 generato con le API Rome

Relazione tra RSS e RDF

Come definito all‘inizio dell‘articolo la versione 1.0 di RSS viene riconosciuta come "RDF Site Summary". Tale versione si basa su RDF, qualsiasi processore RDF può quindi elaborare documenti RSS 1.0. Proprio perchà© la sua natura deriva da RDF, RSS 1.0 si presta a elaborazioni in ottica web semantico.
Per dimostrare l‘analogia e quindi l‘interscambiabilità  in termini di strumenti di elaborazione, si riportano due differenti RSS 1.0 generati con due diversi strumenti. Il primo è Rome, visto precedentemente, il secondo invece è Jena, framework utilizzato per l‘elaborazione di documenti RDF [JENA] e il cui utilizzo è stato riportato negli articoli della serie "web semantico" [MOKA_SEMW_1] [MOKA_SEMW_2].

Figura 8 - API Rome & API Jena

Figura 9 - Analogia RSS 1.0 & RDF

Esempio

Si conclude l‘articolo con un esempio pratico.

In un progetto Offshore (che quindi coinvolgeva due gruppi di lavoro distanti tra loro) a volte venivano modificate le pagine WIKI [Web2_II] senza comunicarlo opportunamente. Magari venivano aggiunte informazioni utili ma che non venivano sfruttate a dovere perchà© ci si dimenticava di dare evidenza all‘altro team non segnalando l‘aggiornamento mediante il WIKI stesso o e-mail o ICQ.

Per sopperire a tale carenza si è pensato di fare un programma che creasse un Feed RSS aggiornato quotidianamente. Il programma deve monitorare le pagine Wiki d‘interesse per la notifica. Di fatto [XWIKI] deve interrogare l‘URL della relativa Wiki history postfissando all‘URL di interesse

?viewer=history&language=it.

ottenendo quindi, per esempio

http://localhost:8080/xwiki/bin/view/<>?viewer=history

Gli URL del Wiki d‘interesse devono essere opportunamente configurati in un file di properties (url.properties):

Project_1=http:///xwiki/bin/view/Offshore/Project_1?viewer=history&language=it
Project_2=http:///xwiki/bin/view/Offshore/Project_2?viewer=history&language=it
Project_3=http:///xwiki/bin/view/Offshore/Project_3?viewer=history&language=it

Il programma legge il file di properties

Properties p=Configurator.loadPropertiesFile(pathUrlFile);

e per ogni URL configurato procede alla sua invocazione.

        Collection c = p.values();
Iterator iter=c.iterator();
while(iter.hasNext()){
String historyWikiUrl = (String)iter.next();
System.out.println("==>" + historyWikiUrl);
String response=UrlInvoker.invokeUrl(historyWikiUrl);

Dalla risposta HTTP ottenuta, il programma effettua un parsing Xerces e applica una trasformazione XSLT al fine di ottenere un XML minimale contenente le informazioni relative alla versione più aggiornata, l‘autore, l‘URL e la data del documento.

Dall‘XML, attraverso xStream [xStream], le informazioni vengono incapsulate nel bean di classe LastWikiUrlVersion che mette a disposizione gli opportuni getter e setter:

public class LastWikiUrlVersion {

private String version = null;
private String author = null;
private String date = null;
private String link = null;

Il valore della versione del bean viene comparato con l‘ultima precedentemente ottenuta, se l‘ultima versione del documento indicata nell‘history è più aggiornata rispetto a quella storicizzata, viene creato l‘RSS mediante le API di Rome.

    boolean res=this.checkIfUpdated(historyWikiUrl,lwuv);
if(res){
// aggiorno l‘RSS !
this.createRSS(rssFileName, pageModified);
}

dove il metodo createRSS risulta essere:

private void createRSS(String fileName, List objectList) {
...
SimpleDateFormat DATE_PARSER = new SimpleDateFormat("yyyy/MM/dd HH:mm");
// type
String feedType = "rss_2.0";
SyndFeed feed = new SyndFeedImpl();
feed.setFeedType(feedType);
feed.setTitle("RSS xWiki changes (created with ROME)- created at: "
+ new java.util.Date());
feed.setLink("http://rome.dev.java.net");
feed.setDescription("RSS to monitorate xWiki project pages changing - created on "
+ new java.util.Date());
feed.setAuthor("A. Rocca, S. Rossini");
Iterator iter=objectList.iterator();
// Per ogni URL configurato ...
List entries = new ArrayList();
SyndEntry entry;
SyndContent description;
//creazione degli item (uno per ogni url di history consultato)
while(iter.hasNext()){
LastWikiUrlVersion lwuv = (LastWikiUrlVersion)iter.next();
entry = new SyndEntryImpl();
description = new SyndContentImpl();
if (lwuv.isModified()){
entry.setTitle("NEW version " + lwuv.getVersion()
+ " of project " + lwuv.getTitle() + " is available");
description.setValue("Version changed since " + lwuv.getDate());
} else {
entry.setTitle("OLD version " + lwuv.getVersion()
+ " of project " + lwuv.getTitle() + " is available");
description.setValue("Version is not changed since " + lwuv.getDate());
}
entry.setLink(lwuv.getLink());
try {
entry.setPublishedDate(DATE_PARSER.parse(lwuv.getDate()));
} catch (ParseException pe) {
pe.printStackTrace();
System.out.println("ERROR: "+pe.getMessage());
}
description.setType("text/plain");
entry.setDescription(description);
// set dell‘item nella lista
entries.add(entry);
}
// aggancio gli item al feed
feed.setEntries(entries);
// scrittura documento RSS
Writer writer;
try {
writer = new FileWriter(fileName);
SyndFeedOutput output = new SyndFeedOutput();
output.output(feed,writer);
writer.flush();
writer.close();
} catch (IOException ioe) {
ioe.printStackTrace();
System.out.println("ERROR: "+ioe.getMessage());
} catch (FeedException fe) {
fe.printStackTrace();
System.out.println("ERROR: "+fe.getMessage());
}
}

Figura 10 - Visione d‘insieme dell‘esempio

L‘RSS cosଠgenerato viene copiato nella webApp dell‘XWiki. Per visualizzare il contenuto dell‘RSS è sufficiente inserire il tag {rss:feed} nell‘opportuna pagina Web:

{rss:feed=http://<>:8080/xwiki/myfeed.rss}

Conclusioni

Con questo articolo terminiamo questa mini-serie dedicata al Web 2.0. In [MOKAWEB2_I] è stata data una visione introduttiva dei principi e delle tecnologie Web 2.0. In [MOKAWEB2_II] si è parlato del Wiki, un importante strumento Web 2.0. In[MOKAWEB2_III] e in questo articolo si è dato spazio a tecniche e tecnologie adottate in Web 2.0.

Riferimenti
[MOKAWEB2_I] S. Rossini - G. Morello, "Il Web 2.0. I parte: principi e tecnologie, una visione introduttiva", MokaByte 117, Aprile 2007

[MOKAWEB2_II] S. Rossini, "Il Web 2.0. II parte: WIKI", MokaByte 118, Maggio 2007

[MOKAWEB2_III] A. Rocca - S. Rossini, "Il Web 2.0. III parte: Ajax", MokaByte 120, Luglio/Agosto 2007

[MOKA_SEMW_1] A. Rocca - S. Rossini, "Semantic Web. I parte: Introduzione a RDF, principi e Data Model", MokaByte 119, Giugno 2007

[MOKA_SEMW_1] A. Rocca - S. Rossini, "Semantic Web. II parte: RDFS e vocabolari controllati", MokaByte 120, Luglio/Agosto 2007

[WPRSS]
http://it.wikipedia.org/wiki/Really_simple_syndication

[MFEEDRD]
http://www.feedreader.com

[ROME]
http://wiki.java.net/bin/view/Javawsxml/Rome

[HRW]
HowRomeWorks
http://wiki.java.net/bin/view/Javawsxml/Rome04HowRomeWorks

[W3CRDF]
http://www.w3.org/RDF

[RSS-1.0]
http://web.resource.org/rss/1.0/

[RSS-2.0]
http://cyber.law.harvard.edu/rss/rss.html

[RSS-0.91]
http://backend.userland.com/rss091

[RSS-0.9]
http://channel.netscape.com/publish/help/quickstart.html

[OKNotizie]
http://oknotizie.alice.it/

[Digg]
http://www.digg.com/

[xStream]
http://xstream.codehaus.org

[XWIKI]
http://www.xwiki.org/xwiki/bin/view/Main/WebHome

Condividi

Pubblicato nel numero
121 settembre 2007
Stefano Rossini è nato a Giussano (MI) il 29/10/1970 e ha conseguito il diploma universitario in Ingegneria Informatica presso il Politecnico di Torino. Ha maturato più di venti anni di esperienza in diversi progetti Enterprise mission-critical ricoprendo i ruoli di IT Program Manager, Project Manager & Software Architect presso importanti…
Articoli nella stessa serie
Ti potrebbe interessare anche