Partecipando alle riunioni dei soci di DOT NET Campania ho capito quanto fosse necessario cominciare a studiare un po’ di Javascript in prospettiva di lavorare su HTML 5. La prima esigenza che ho avvertito è stata quella di collegare la pagina a una fonte dati. Ho quindi creato una pagina HTML contenente una mappa di Google e dei marker posizionati in punti estratti mediante un servizio OData.
Il servizio OData è disponibile al seguente indirizzo ed offre informazioni su una serie di concerti tenuti dagli U2 negli anni 80 in Irlanda. Un esempio di concerto (denotato dal tag <entry>) è il seguente:
![CropperCapture[31]](http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Blogs.Components.WeblogFiles/salvatore.metablogapi/1385.CropperCapture31_5F00_thumb_5F00_2CC1BC8B.jpg "CropperCapture[31]")
Per consumare il servizio in una pagina HTML tramite Javascript ho utilizzato una fantastica libreria chiamata datajs, pubblicata su Codeplex al seguente indirizzo.
![CropperCapture[32]](http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Blogs.Components.WeblogFiles/salvatore.metablogapi/3463.CropperCapture32_5F00_thumb_5F00_7955D361.jpg "CropperCapture[32]")
Il body della pagina si limita ad associare all’evento onload la funzione initialize:
<body onload="initialize()">
<div id="map_canvas"></div>
</body>
</html>
![CropperCapture[33]](http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Blogs.Components.WeblogFiles/salvatore.metablogapi/3051.CropperCapture33_5F00_thumb_5F00_7BCEDF52.jpg "CropperCapture[33]")
La funzione initialize crea la mappa Google e poi tramite la libreria datajs legge il servizio Odata tramite la function (data). In essa eseguiamo un loop sui risultati della query: ad ogni concerto associamo un marker sulla mappa Google invocando la funzione addMarker.
![CropperCapture[34]](http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Blogs.Components.WeblogFiles/salvatore.metablogapi/0083.CropperCapture34_5F00_thumb_5F00_0B224162.jpg "CropperCapture[34]")
Il risultato è il seguente:
![CropperCapture[35]](http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Blogs.Components.WeblogFiles/salvatore.metablogapi/1856.CropperCapture35_5F00_thumb_5F00_3D396BDF.jpg "CropperCapture[35]")
Allego il codice sorgente della pagina HTML e la libreria Javascript necessaria al collegamento.
Gli Smartphone più comuni consentono di associare ad ogni foto le coordinate geografiche del punto in cui è stato eseguito lo scatto. Verifichiamolo salvando una foto su un computer e andando a visualizzare le proprietà del file corrispondente.
Quando carichiamo la foto su Flickr, l’interfaccia web ci chiede se vogliamo utilizzare o meno queste coordinate
Flickr mette a disposizione degli sviluppatori di software un insieme di API per l’accesso agli oltre 5 miliardi di foto presenti sul sito. Quasi quasi tutte le funzionalità eseguibili dal portale di Flickr sono disponibili tramite le API. L’utilizzo è gratuito per applicazioni non commerciali. Per iniziare occorre richiedere una chiave per l’accesso alle API al seguente indirizzo:
In particolare, Flickr offre al seguente indirizzo un servizio di reverse geocoding che partendo dalle coordinate geografiche date in ingresso cerca di estrarre informazioni sulla località cercata.
Il risultato della query è disponibile in vari formati (in figura è mostrato l’xml rest). Analizzando l’output si scopre che il tag place ha una proprietà associata chiamata woeid. Tempo fa, ho scritto un post sul tentativo da parte di Yahoo di mettere a disposizione dei suoi utenti un database geografico chiamato GeoPlanet. Il progetto è nato con l’ambizioso scopo di gestire TUTTE le località “permanenti” e dotate di nome sul pianeta Terra. Vi rimando al mio post per scoprire altri dettagli sul progetto. In rete si trova un GeoPlanet Explorer che consente di visualizzare tutte le informazioni associate a un woeid.
Quello che ci interessa di più è che le API di Flickr sono collegate a quelle di Yahoo e ciò apre orizzonti del tutto nuovi.
Sul portale Codeplex troviamo l’ultimo ingrediente necessario: la libreria FlickrNET. Si tratta di una libreria .Net scritta interamente in C# per semplificare l’accesso alle API Flickr. Esistono librerie dll anche per versioni di Silverlight superiori alla 3.0,per Windows Phone e per Monotouch su Iphone.
La prima cosa da fare è creare un’istanza dell’oggetto Flickr:
Come passo successivo eseguiamo una ricerca nell’insieme di foto messe a disposizione di un particolare utente. Un utente di Flickr è identificato univocamente da uno User ID (nel mio caso è 35077877@N00). La libreria offre una classe chiamata PhotoSearchOptions per gestire i criteri di ricerca. Anzitutto creiamo una istanza della classe specificando nel costruttore lo User ID. Chiediamo poi alla libreria di aggiungere alle foto le informazioni geografiche (non disponibili per default).
Estraiamo quindi la collezione di foto associate ai nostri criteri di ricerca:
Possiamo scorrere quindi la lista delle nostro foto (nel mio caso 44)
Ogni oggetto Photo è caratterizzato da un PhotoId univoco. Estraiamo le informazioni associate a un particolare ID:
Il codice ci restituisce il WOEID associato alla foto. Supponiamo ora di voler cercare tutte le foto presenti su Flickr scattate in una particolare area definita da un particolare WOEID. Dobbiamo modificare i criteri di ricerca nella maniera seguente: non specifichiamo più lo UserID ma solo il WoeID della zona a cui siamo interessati.
Nel mio caso particolare la ricerca restituisce ben 158 risultati. Ecco uno snippet di quanto viene visualizzato nella griglia.
Possiamo anche ricercare le foto per Tag:
Per accedere a Flickr da un’applicazione per Windows Phone, bisogna anzitutto accedere alla libreria Flickr.NET specifica per WP7. Il codice di una ricerca è leggermente diverso per tenere conto della chiamata asincrona alle API di Flickr.
La funzione DoSomething agisce sui controlli dell’interfaccia utente.
Il risultato è il seguente (scusate al solito la bruttezza dell’interfaccia!)
Conoscendo il WOEID associato alla foto è possibile invocare tutti i web service offerti da Yahoo. Ecco ad esempio uno snippet di codice che estrae le condizioni del tempo e la temperatura (l’indirizzo del servizio web è il seguente: http://xml.weather.yahoo.com/forecast). Come vedrete siamo nella giornata più calda dell’anno!
In questo post vedremo come utilizzare le estensioni spaziali di SQL Server 2008. Prima di entrare nel dettaglio, sarà necessario dare qualche definizione.
Una Base di dati spaziale o Database spaziale è una base di dati ottimizzata per archiviare e interrogare dati correlati ad oggetti nello spazio, tra cui, punti, linee e poligoni. Nei database spaziali sono integrate quindi delle funzionalità aggiuntive per processare tipi di dati spaziali. L'Open Geospatial Consortium ha creato le specifiche Simple Features che stabiliscono degli standard per l'aggiunta di funzionalità spaziali ai database.
A partire dalla versione 2008, SQL Server supporta i tipi spaziali, in accordo con le specifiche Open GIS. I tipi spaziali introdotti sono due: Geometry and Geography.
Geometry
Questo tipo consente l'utilizzo di dati geometrici, ossia punti, linee e poligoni, all'interno del sistema di coordinate euclideo. Viene usato per rappresentare informazione in un piano a 2 dimensioni. Le unità di misura sono arbitrarie: metri, miglia, pixel, etc.
Geography
Poiché la Terra non è piatta c’è il problema di rappresentare un punto su di essa usando una matematica bi-dimensionale. Le carte geografiche che conosciamo sono proiezioni del mondo reale su un piano. Esistono tanti metodi per eseguire una proiezione; ciascuno coi suoi pregi e difetti. Ad esempio, una carta europea tende a minimizzare le distorsioni su tale regione spostandole verso i poli: per questo motivo la Groenlandia e l’Antartide appaiono molto più grandi di quanto non siano in realtà. Un tipo Geometry non è adatto a rappresentare un punto sulla Terra soprattutto quando si vuole condividere l’informazione con altre persone che utilizzano proiezioni differenti. Fortunatamente, possiamo usare un sistema di coordinate geografiche per rappresentare punti sul pianeta o su qualsiasi superficie ellissoidale.
Il tipo Geography usa la latitudine e la longitudine per identificare un punto. E’ importante sottolineare che Latitudine e Longitudine non sono valori assoluti universalmente accettati: il meridiano primo e la longitudine 0 sono in realtà arbitrari. Ad esempio, Il meridiano primo usato dal GPS è spostato di 100 metri ad est rispetto a quello ritenuto “ufficiale”.
Una volta stabilita l’origine del sistema di riferimento va affrontato un altro problema: per calcolare la distanza tra due punti sul globo occorre conoscere il raggio della Terra che non è uniforme. Quando esprimiamo una località in termini di coordinate globali, queste sono basate su un modello della Terra che è molto accurato su quell’area ma non altrove. I parametri che caratterizzano il modello utilizzato sono noti come “Spatial Reference System” (SRS). E’ importante conoscere quale SRS si è utilizzato per un insieme di dati per salvaguardare l’accuratezza dei dati. Il SRS più usato attualmente è chiamato WGS84.
Vi rimando a questo link per una trattazione più dettagliata su questi nuovi tipi.
Partiamo da una tabella in SQL Server (U2_Concerts) che contenga due campi esprimenti la latitudine e la longitudine di un punto associato al record. Aggiungiamo un campo (che chiameremo Location) di tipo Geography e aggiorniamo la tabella eseguendo il seguente comando all’interno del Management Studio di SQL Server:
UPDATE U2_Concerts SET Location = GEOGRAPHY::Point(latitude,longitude,4326);
Il valore del campo Location viene costruito a partire dalla latitudine e dalla longitudine e da un numeretto magico (4326) che rappresenta il WGS84.
Eseguiamo ora una query sulla tabella U2_Concerts:
SELECT * FROM [ProvEuropa].[dbo].[U2_concerts]
Nella regione dei risultati compare un nuovo tab chiamato Risultati Spaziali che mostra visivamente il risultato della query.
Introduciamo ora nella nostra analisi una seconda tabella spaziale. Per costruirla partiamo da uno shapefile (vedi post precedente) contenente le province dell’Europa.
Per importare in SQL Server 2008 lo shapefile possiamo utilizzare un tool chiamato Shape2SQL.
A differenza della tabella precedente, ora abbiamo a che fare con 1991 poligoni descritti con un tipo Geometry. Possiamo quindi eseguire query spaziali più sofisticate:
DECLARE @Napoli geometry;
SET @Napoli=(SELECT TOP 1 geom FROM province WHERE PROVNAME='Napoli');
Definiamo cioè un oggetto geometry chiamato @Napoli e lo identifichiamo selezionando il poligono cha abbia come attributo PROVNAME “Napoli”. A questo punto selezioniamo dalla tabella tutti quei poligoni che confinano con @Napoli.
Il risultato della query è il seguente (in forma tabulare e grafica):
Costruiamo ora una query che utilizzi entrambe le tabelle e che mostra tutti i concerti avvenuti nella provincia di Milano:
SELECT geom, id, NUll, NUll FROM Province WHERE ProvNAME='Milano'
UNION ALL
SELECT Location.STBuffer(800), Latit, Longit, Data FROM U2_concerts
Utilizzando il Generatore report 3.0 di Microsoft SQL Server 2008 R2 è possibile stampare una mappa a partire da query spaziale. E’ possibile, inoltre, inserire Bing Maps come layer addizionale:
Concludiamo l’articolo parlando di nuovo della libreria SharpMap, descritta nello scorso post.
SharpMap è in grado di caricare layer provenienti da tabelle di SQL Server. Anzitutto definiamo un oggetto di tipo
SharpMap.Data.Providers.SqlServer2008 shpDS;
E lo istanziamo nella maniera seguente
shpDS = new SharpMap.Data.Providers.SqlServer2008(cnnString,”MyTable”, "geom", "ID");
dove cnnString è la stringa di connessione al database, “MyTable” è il nome della tabella contenente i dati che vogliamo caricare, “geom” è il relativo campo di tipo GEOMETRY e ID è la chiave della tabella.
E’ sempre consigliabile validare la geometria usando Sharpmap mediante la seguente chiamata:
shpDS.ValidateGeometries = true;
In caso contrario, l’applicazione darà spesso errori dovuti alla conversione da Shapefile. Definiamo quindi un oggetto di tipo layer
SharpMap.Layers.VectorLayer layer = new SharpMap.Layers.VectorLayer("first layer");
E settiamo la sua sorgente dati con il provider appena costruito:
layer.DataSource = shpDS;
A questo punto basta definire lo stile da utilizzare nella visualizzazione facendo attenzione a non usare colori di riempimento dei poligoni che nascondano le linee e i punti.
Il layer così costruito può essere aggiunto alla mappa. La procedura va ripetuta per tutti i layer che vogliamo sovrapporre. Nella immagine seguente la mappa contiene due layer: le nazioni del mondo (poligoni) e i punti estratti dalla tabella U2_Concerts appartenenti all’Italia.
Nella prossima immagine invece sono rappresentate le nazioni del mondo (con zoom sugli USA),i fiumi (in verde) e gli epicentri dei terremoti avvenuti nella storia degli Stati Uniti (punti rossi).
In conclusione, abbiamo introdotto le estensioni spaziali di SQL Server e visto qualche semplice esempio di suo utilizzo. L’argomento è complesso e relativamente giovane ma col passare del tempo sicuramente gli strumenti a disposizione del programmatore o analista GIS miglioreranno così come la documentazione.
Per i programmatori .NET la libreria SharpMap è lo strumento che garantisce una continuità di lavoro rispetto all’utilizzo di shapefile.
Mi è stato chiesto di sviluppare un’applicazione web nella quale selezionando una nazione da una mappa fosse possibile visualizzare sotto forma di Chart dei dati estratti da un database relazionale. La prima demo che ho realizzato utilizzava Yahoo Maps (preferito a Google per le minori limitazioni sull’uso commerciale). Tuttavia il cliente si è lamentato del fatto che la mappa fosse troppo sofisticata e che l’utente si sarebbe facilmente distratto a giocare con i vari tipi di visualizzazione disponibili. Mi ha dunque chiesto una mappa più basilare ma che fosse anche configurabile (ad esempio visualizzare una certa nazione con un dato colore) e rispondesse all’evento di click su di essa.
Dopo un po’ di studio la mia scelta è stata quella di utilizzare una mappa in formato Shapefile. Si tratta di un popolare formato vettoriale per sistemi informativi geografici, sviluppato e regolato all’inizio degli anni 90 dalla ESRI (leader mondiale nel campo dei software geografici). Di fatto è diventato uno standard per il dato vettoriale spaziale, e viene usato da una grande varietà di sistemi GIS.
Con Shapefile si indica di norma un insieme di file che hanno in comune il prefisso dei nomi (per es. "countries.*"). Tre file sono obbligatori, senza di essi uno Shapefile non è tale;
- .shp - il file che conserva le geometrie
- .shx - il file che conserva l'indice delle geometrie;
- .dbf – il database degli attributi
Gli Shapefile registrano semplicemente i dati geometrici primitivi: punti, linee e poligoni. Da sole queste primitive, dette feature, non sono utili, mancando degli attributi che specificano cosa queste primitive rappresentino. Perciò una tavola di record registra proprietà e attributi per ogni primitiva (shape) dello Shapefile. Le shape, insieme ai dati attributari, possono creare infinite rappresentazioni di dati geografici, da cui a loro volta dipende la potenza e l'accuratezza delle analisi geo-spaziali che sono il fine dei GIS.
Partiamo con un semplice esempio. Al seguente indirizzo è possibile scaricare uno Shapefile contenente le nazioni del mondo.
Con Microsoft Office Access possiamo visualizzare il contenuto del file .dbf. Attenzione che per aprire il file bisogna rinominarlo con un nome al massimo di 8 caratteri (nel 2011 succedono ancora queste cose!): create quindi prima una copia del file originario e poi rinominatelo. Il file dbf è una tabella di questo tipo:
Senza entrare nel dettaglio, a noi interessa principalmente il campo contenente il nome della nazione e la sua posizione all’interno della tabella: quindi, NAME e 0.
Come possiamo accedere ad uno Shapefile sotto ambiente .NET? Su Codeplex (la community Open Source) troviamo un progetto chiamato SharpMap consistente in una libreria che fornisce accesso a molti tipi di dati GIS, Shapefile compreso. La libreria può essere usata sia per applicazioni desktop che web. E’ stata scritta in C# ed è basata sul framework .Net 2.0. Vi consiglio come primo approccio di scaricare la versione 0.9, lasciando stare per un po’ la più complessa versione 2.0.
Il primo progetto che andiamo ad esaminare è una semplice applicazione desktop. Una volta compresi gli aspetti base della libreria, costruiremo una pagina web.
L’oggetto base della libreria è la Map. Ad essa vengono aggiungi i cosiddetti Layer. Nel nostro caso abbiamo due Layer: il primo contenente lo Shapefile appena descritto e il secondo una collezione di punti che andremo ad aggiungere sulla mappa mediante click. Un Layer ha un datasource (nel nostro caso il percorso dello shapefile) e possiamo associare ad esso un Theme. Cos’è un Theme? Supponiamo di voler colorare in rosso l’Italia, lasciando in verde tutte le restanti nazioni.
Nella costruzione dell’oggetto tema, indichiamo una funzione delegata che agisce su tutte le shape contenute nel datasource. Nel nostro caso abbiamo 211 poligoni (uno per nazione). Ogni poligono ha come attributo il nome della nazione (nel campo 0). Con un semplice check sull’attributo possiamo quindi cambiare il colore di riempimento del poligono.
La Map, infine, viene posta come proprietà immagine di una PictureBox. Quando l’utente clicca col Mouse in un punto della PictureBox, abbiamo due coordinate X ed Y che vanno trasformate in coordinate geografiche. SharpMap esegue la trasformazione mediante il metodo ImageToWorld.
Il codice allegato mostra come eseguire lo Zoom e il centramento della mappa. Inoltre, viene indicato anche come aggiungere punti a un Layer dell’oggetto Mappa.
La libreria SharpMap è molto semplice da utilizzare e al tempo stesso garantisce allo sviluppatore tutto quanto gli occorre per realizzare progetti complessi quali, ad esempio, il collegamento di mappe a dati contenuti su database relazionali esterni.
In allegato troverete anche una semplice pagina aspx che carica lo stesso Shapefile appena mostrato. Il codice è basato su un progetto che ho trovato su CodeProject al seguente indirizzo. Nel caso di una pagina web entra in gioco il fattore ricaricamento della pagina ad ogni invocazione lato server. E’ dunque necessario conservare tramite una ViewState l’informazione relativa all’ultimo centro e zoom della mappa. La Mappa viene caricata come proprietà ImageUrl di un controllo ImageButton.
Occorre però aggiungere un httpHandler nella sezione system.web della Web.config del sito:
Concludo segnalandovi che da poco è nato sotto Codeplex un nuovo progetto, MapsUI, basato su SharpMap ed ottimizzato per le seguenti piattaforme: Silverlight, WPF, MS Surface, WinForms, Compact Framework e Windows Phone.
Ecco i due progetti in allegato:
Sin dai tempi del VB6 ho portato avanti un progetto che mi ha consentito di testare le nuove tecnologie che si sono susseguite in questi anni. E’ un progetto nato per mettere ordine nella mia eterogenea collezione di materiale musicale. Infatti, nonostante abbia testato decine e decine di software, non sono mai stato soddisfatto dalla loro maniera di organizzare i dati. Vi anticipo che in questo campo sono un freak; quindi le mie richieste ai più parranno eccessive.
Il modello di database che adotto attualmente è in parte derivato da quello introdotto sul sito web MusicBrainz che offre ai suoi utenti un web service REST-based per estrazione di dati. Un altro sito che offre gratuitamente dati in formato XML è DiscoGS. Questi due siti sono stati fondamentali nella scrittura di programmi accessori che ho utilizzato per riempire il mio database. In uno dei prossimi post vedremo come si possono eseguire query su questi web service.
La prima tabella (e di conseguenza il primo oggetto) di cui voglio parlarvi è quella degli artisti, Artists ( consentitemi d’ora in poi, di utilizzare la lingua inglese). Un Artist è un musicista, una persona che produce materiale sonoro o che partecipa alla produzione di materiale sonoro. Mentre in MusicBrainz un Artist può essere anche un gruppo di persone, nel mio approccio un Artist è sempre una singola persona. Nel database MusicBrainz, gli U2 sono un Artist; nel mio caso nella tabella Artists ho 4 record: Bono Vox, Larry Mullen, Adam Clayton, the Edge (i 4 membri degli U2). Perché questa scelta? Un gruppo musicale non è un’entità monolitica e immutabile. Consideriamo l’esempio dei Pearl Jam: nel corso della loro vita musicale alla batteria si sono succeduti ben 5 Artist. Da appassionato musicale, questa è un’informazione che voglio conservare nel mio database. Ogni canzone, inoltre, ha degli autori dei testi e dei compositori musicali. Molti gruppi tengono a sottolineare questi ruoli nei libretti associati al loro materiale. Così, la canzone “Alive” dei Pearl Jam ha come “Composer” Vedder e Gossard (cantante e chitarrista del gruppo). Ultimo motivo per conservare tutte le individualità all’interno di un gruppo, è dato dalle molteplici apparizioni di singoli elementi di un gruppo ad altri progetti musicali. Ad esempio, al concerto per la raccolta di fondi per il Tibet hanno partecipato i Pearl Jam, ma non al completo: erano presenti solo Eddie Vedder e Mike McCready.
I campi della tabella Artists sono quelli che riteniamo più idonei alla descrizione dell’Artist. Al momento, sono i seguenti
![clip_image001[4]](http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Blogs.Components.WeblogFiles/salvatore.metablogapi/1018.clip_5F00_image0014_5F00_thumb_5F00_1200BDD4.png "clip_image001[4]")
![Devil]( "clip_image001<img src=")
" border="0" alt="clip_image001
" src="http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Blogs.Components.WeblogFiles/salvatore.metablogapi/5277.clip_5F00_image0016_5F00_thumb_5F00_3CC8FC19.png" width="212" height="188" />
La seconda tabella, chiamata Groups, definisce gli aggregati di Artist che hanno prodotto in maniera ufficiale un prodotto musicale. L’esempio più immediato è il nome che appare sulla copertina di un disco. Da notare che nel mio approccio un Group può anche essere composto da un solo Artist (nell’immagine Bob Dylan).
Un Group è caratterizzato da un nome, da una data di formazione e una di eventuale scioglimento, da un campo di descrizione e da una foto. Nel caso di Group costituito da un singolo Artist, la data di scioglimento può corrispondere a quella di abbandono delle scene o della sua morte.
Sarete sorpresi dal fatto che in Groups non compaia alcuna relazione con la tabella Artists. Il GroupID è uno short-cut rapido nei casi in cui non siamo interessati alla storia del Group. Quindi la tabella dei Dischi (che vedremo a breve) presenterà una chiave esterna che si collegherà a Groups.
La terza tabella Group_Histories contiene la storia di un gruppo musicale ed è collegata a Groups.
La prima formazione dei Pearl Jam, nata nel Giugno 1990 e sciolta ad Aprile 1991 era composta da Vedder, McCready, Gossard, Ament e Krusen. Avremo dunque una chiave esterna per collegare la tabella all’entry Pearl Jam in Groups. Come colleghiamo la tabella Artists? Una soluzione potrebbe essere quella di definire in Group_Histories un congruo numero di campi del tipo Artist_1_ID,….., Artist_N_ID. Ma quando ci dobbiamo fermare? Se ne inserissimo 10. quanti sarebbero i Group che necessitano di tanti campi? Davvero pochi. La scelta di sovraprogettare una tabella per soddisfare casi rari non mi è mai piaciuta. Una seconda alternativa (che ho usato più spesso in passato) sarebbe quella di creare una terza tabella il cui singolo record sia definito dalla coppia di chiavi GroupPastID e ArtistID. Nel caso dei Pearl Jam, per il singolo record di esempio avrei bisogno di 5 record (uno per ogni Artist) in questa tabella di collegamento. La soluzione è impeccabile ma necessita di una tabella aggiuntiva costituita da sole chiavi esterne.
La mia soluzione nasce dall’osservazione che una singola stringa (il campo GroupArtists) contenente gli ID degli Artist separati da una virgola fornisce tutta l’informazione necessaria: 11,12,13,14,17.
La seguente immagine mostra come in sole 6 record sia compresa tutta la storia dei Pearl Jam.
La semplificazione del database è evidente ma è chiaro che ci sono dei costi da pagare:
1) Dovremo essere noi a gestire l’integrità referenziale dei dati assicurandoci che la stringa GroupArtists contenga ID esistenti nella tabella Artist.
2) Dovremo analizzare tante stringhe!
I vantaggi di questo approccio diventano ancora più evidenti quando consideriamo la tabella delle canzoni: Songs. Come associamo una canzone ad un Group? Da un lato voglio avere immediatamente l’informazione che una canzone è di un dato gruppo; dall’altro voglio preservare gli Artist che l’hanno composta. Ecco la tabella Songs caratterizzata dal fatto di non avere chiavi esterne.
Tutta l’informazione sugli autori è contenuta nella stringa song_Authors_ID. Vediamo come esempio la canzone “Alive” dei Pearl Jam.
Abbiamo due separatori: il punto e virgola e la virgola. A sinistra del punto e virgola appare l’ID del Group (Pearl Jam) ossia la chiave della tabella Groups. A destra abbiamo gli ID degli Artist autori della canzone, separati da una virgola. La flessibilità è assoluta: consideriamo il caso della canzone “The Saints Are Coming” composta dagli U2 e dai Green Day, due gruppi musicali, e scritta da Bono, cantante degli U2. La Stringa Song_Authors_ID sarà semplicemente: “1,51;2”: quindi a sinistra del Punto e Virgola appariranno i due Group e a destra l’Artist.
Procediamo con la costruzione della tabella che conterrà gli elementi della nostra collezione che definiamo come Release di un Group.
E’ necessaria una tabella che descriva su quale mezzo fisico viene distribuita la Release. Utilizzando il gergo di Music Brainz definiamo la tabella Format_Types. In figura sono mostrati i record attualmente contenuti nel mio database. Questa tabella è frutto del progresso tecnologico e quindi evolve nel tempo.
Occorre poi una tabella che descriva il tipo di Release. La notazione usata è quella di MusicBrainz.
La Tabella Release è “classica” nella sua concezione e non necessita di particolari descrizioni. L’unica osservazione è che bisogna evitare l’atroce e diffusissima formula AAVV, ossia Autori Vari. Ad ogni Release dovrà corrispondere un Group quanto più possibile significativo. Prendiamo in considerazione il caso peggiore: una compilation di canzoni degli anni ’80! Definiremo un Group dal nome “Gruppo Artisti degli Anni 80” e poi andremo ad inserire in GroupHistories un record con la lista di tutti i Group compresi al suo interno.
La tabella Release contiene l’immagine della copertina associata al materiale. Devo ammettere che non ho ancora deciso quale sia la soluzione migliore: conservare l’immagine nel database o semplicemente il percorso del file sul disco. Immagazzi nare tutto nel database è ovviamente la scelta più coerente, tuttavia quando si passa alla costruzione delle interfacce utente Il data binding di un controllo a un campo immagine non è un’operazione banale (soprattutto in progetti WPF o Slverlight) .
L’ultima tabella da analizzare è quella delle Tracks contenute in una Release. Esistono due ordini di problemi che complicano la sua definizione:
- Chi sta cantando
- Cosa si sta cantando
Prendiamo un concerto dei Pearl Jam in cui ad un certo punto venga invitato sul palco Ben Harper. Questo nuovo aggregato di Artist esegue una canzone che è in realtà la somma (Medley è il termine preciso) di due altre canzoni: una dei Pearl Jam e la seconda di Neil Young. Ovviamente si potrebbe inserire tutto in un bel campo “Note” ma con gli anni ho imparato che questo tipo di campo serve spesso solo a coprire gli errori di progettazione o le tardive indicazioni di un cliente.
Il campo stringa SongID contiene la lista delle Songs contenute nella Track separate da una virgola. Il campo TrackPerformerRelationID è una stringa contenente due separatori (; e ,) per darci la possibilità di includere tutti gli Artist e Group coinvolti nell’esecuzione della Track.
Dal punto di vista dell’interfaccia utente, una pagina web associata ad una Track sarà qualcosa del genere
con 3 cloud (nella zona a sfondo grigio): la prima relativa al Group, la seconda agli Artist che han partecipato alla sua esecuzione, la terza alle Song contenute nella Track.
Concludendo, le richieste di un appassionato di musica (me stesso) mi hanno spinto a progettare un database sperimentale che godesse delle seguenti qualità; semplicità, flessibilità e completezza di informazione. Il compito di estrarre tale informazione non è necessariamente più complesso ma è sicuramente diverso dall’eseguire query su viste piene di join.
Giuseppe “Pino” Grella è Professore ordinario presso la Facoltà di Fisica dell’Università di Salerno. “Nato” come Fisico teorico, ha spostato i suoi campi di ricerca alla Fisica sperimentale delle particelle elementari. Assieme al Prof. Romano ha fondato un gruppo di ricerca che è sempre stato all’avanguardia nazionale e internazionale. Caratteristica peculiare del gruppo è l’aver adottato sin dall’inizio le tecnologie Microsoft, sia nella gestione degli apparati sperimentali che nell’analisi dati. Pino è una persona di straordinaria cultura e una vera enciclopedia vivente sulla storia dei linguaggi informatici. In questo primo incontro ci parlerà dei suoi esordi informatici mentre nel secondo incontro parleremo esclusivamente della sua grande passione, il Visual Basic.
/**********************************************************************************************/
P. - Il mio primo contatto con l’informatica è stata una lettura di un testo che acquistai presso le Edizioni Paoline…
S. Chi l’avrebbe mai detto!
P. ..sui computer. Stiamo parlando del 1966-1967 quando praticamente il calcolatore veniva chiamato Cervello Elettronico o Cervellone, termine che i giornalisti non hanno poi più smesso di usare. Era un approccio tipico di quel periodo: l’uso di schede perforate, etc. Poi quando ero studente incontrai le schede perforate durante il corso di Sperimentazioni di Fisica. Si usava un PDP-11.
S. Quindi bisognava scrivere un programma in Fortran e…
P. Si! E usare la perforatrice. Si trattava di programmi molto semplici calcolo di medie e deviazioni standard. Ad essere onesti, trovavo più comodo lavorare a mano. Per esempio, ero più veloce io a calcolare a mano le radici quadrate.
S. Vero! Ricordo che alle Scuole Medie passavo ore a calcolare radici quadrate! Non credo che oggi venga più insegnato….
P. Alla fine c’era il solito traffico di schede già rodate. Certo, bastava un piccolo errore e dovevi punzonare tutto da capo. E te ne accorgevo solo a run time! Altro che debugger! Però sono esperienze che ti affinano l’attenzione. C’è un esempio clamoroso di errore... La sonda Mariner 1, stiamo parlando del 1962, ebbe un problema alla partenza e fu subito fatta esplodere in volo per evitare che causasse danni alla popolazione. Si dice che tutto nacque da un errore in una linea di codice Fortran. Come saprai, il Fortran ignora gli spazi: è un linguaggio che ricostruisce l’espressione dal contesto. Quindi, pensa all’istruzione DO 10 I=1,50 Se al posto della virgola metti un punto, crei una variabile dal nome DO10I con valore 1.50! Poiché non c’era ancora la dichiarazione obbligatoria delle variabili, si trattava di una istruzione lecita.
Continuando con la mia storia, ricordo che un amico mi portò da un suo conoscente che aveva comprato un Apple II. Rispetto ai calcolatori mostri che conoscevo si trattava sicuramente di una rivoluzione. Questa persona era un farmacista che aveva da poco subito un intervento cardiaco; quindi, aveva deciso di spendere tutti i suoi soldi togliendosi un po’ di sfizi! Pensava di creare un inventario di tutti i prodotti che vendeva ma ovviamente all’epoca non esistevano software gestionali!
Poi bisogna passare ai tempi in cui mi trasferii a Salerno. All’Università nel 1984 acquistarono il primo Mainframe, un VAX 11/750 di cui sono stato il System Manager per diversi anni. Io ero un fisico teorico ma proprio in quel periodo mi trovavo in una fase di transizione e quindi mi lanciai con entusiasmo su questa nuova esperienza, pur non avendo nessun background teorico. Appresi tutto sul campo e sui manuali splendidi della Digital: il sistema operativo VMS e una sfilza di compilatori che la Digital praticamente regalava.
S. – Cosa ricordi di questi compilatori?
P. I compilatori Digital a mio parere erano quelli più chiari in fase di diagnostica. Scovare un errore era facilissimo perché il traceback ti portava direttamente nel punto dove avevi sbagliato e ti dava tutti i dettagli dell’errore. Cosa, che a mio a parere, è scomparsa nei compilatori successivi che sono diventati sempre più criptici.
P. Installammo di tutto a partire dal Pascal. Devo dire che all’epoca portavo con me un ricordo negativo del FORTRAN per colpa di quelle schede ma poi, col tempo, mi sono reso conto che si tratta di un linguaggio di tutto rispetto per quando riguarda le applicazioni matematiche dove, a mio parere, rimane insuperato. Si dice che è un linguaggio poco sicuro ma in realtà lo sono i programmatori! E’ chiaro che se si comincia ad usare notazioni sbagliate (variabili chiamate ii oppure iii oppure iiii tutte nello stesso pezzo di codice ) prima o poi si commette la porcheria.
S, Quindi tu all’epoca scrivevi programmi in Pascal.
P. Si. L’estensione prodotta dalla Digital del Pascal era potentissima. Del Pascal vero e proprio c’era solo la sintassi. Ricordo che nell’estensione era possibile usare array di dimensione variabile, cosa che nel linguaggio ufficiale non esisteva.
Poi venne il momento di ADA. Mi incapricciai di questo linguaggio perché avevo trovato un manuale della Zanichelli dove veniva spiegata la sua nascita. Trovai interessante i motivi che portarono a creare il linguaggio allontanandosi dal Pascal. Certo, per sua natura, è un linguaggio molto rigido… però (soprattutto con la sua estensione ADA-95) consentiva la programmazione orientata ad oggetti. Non sono gli oggetti del C++, sono oggetti un po’ più seri! ADA è un linguaggio che garantisce una solidità eccezionale: anche se al solite dipende dal back-end….Ah ecco, ho dimenticato di citare poi i miei trascorsi con Eiffel!
S.- Caspita! Il progenitore dei linguaggi ad oggetti!
P. Si. Sotto Windows se ne trova una versione gratuita. Devo dire però che può dare fastidio il fatto che tutto sia un oggetto, anche un numero! Bertrand Meyer, l’inventore del linguaggio, ha aggiustato un po’ le cose consentendoti di calcolare semplicemente 3+2 ma devi sempre ricorrere alle classi. D’altra parte, però, a ben pensarci è un linguaggio più coerente: i cosiddetti linguaggi ad oggetti dove tutto è un oggetto tranne quelle cose che devono rispettare la vecchia notazione e che poi, sotto sotto, sono ancora oggetti….insomma!
S. Torniamo un attimo ad ADA. Linguaggio che nasce per..
P. ADA nasce per l’esigenza del Dipartimento della Difesa degli Stati Uniti di unificare tutti i compartimenti sotto il suo controllo che usavano ciascuno un proprio linguaggio di programmazione, ad esempio lo SmallTalk. Era sicuramente un problema di non facile soluzione. Fu indetta una fase di selezione alla fine della quale rimasero solo 4 aziende, il cui nome rimase strettamente riservato. A ciascuna di esse fu assegnato il nome in codice di un colore! Vinse questo team capeggiato dal francese Jean Ichbiah che, come ho detto prima, prese spunto dal Pascal estendendolo. In definitiva un linguaggio potente e solido: ciò che serviva esattamente agli Americani. Negli Anni 90 venni convocato dal Ministero della Difesa per tenere un corso rivolto al personale che doveva passare da CORAL per il controllo del traffico aereo ad ADA. Recentemente, ho incontrato per caso uno dei miei allievi che mi ha confessato come quel passaggio li avesse salvati! ADA era una soluzione quasi naturale per scrivere programmi di controllo sicuri. Non potevi permetterti di avere thread che girassero inutilmente in programmi real-time.
(Nota: Esiste A# per .NET, un port di ADA per il framework .NET. Lo potrete trovare al seguente indirizzo)
All’epoca in cui a Salerno si trasferì il Prof. G. Romano, si pensava di realizzare un telescopio per l’osservazione di neutrini . Era appena uscito sul mercato l’Intel 286 e lo acquistammo subito perché ci serviva potenza di calcolo per Simulazioni Montecarlo! E si pensò di utilizzare Occam, un linguaggio di programmazione nato per architetture parallele. Volendo anche ADA consentiva una programmazione multi-tasking, comunque allora c’era qualcuno che usava questo Occam, un linguaggio bizzarro a dire il vero. Fortunatamente la cosa morì lì ma almeno mi convinsi che qualche tentativo per entrare nel mondo dei PC andava fatto. Infatti acquistati un piccolo portatile che poi cambia subito con uno a colori della Toshiba che mi costò un occhio della testa: 5 – 6 milioni e stiamo parlando del 1989…
S. – Prima abbiamo parlato del VAX. Tu sei passato dal VAX a Windows senza mai lavorare su un sistema Unix o Linux…
P. - Mai! Invece i miei colleghi della facoltà di Informatica, che lavoravano anch’essi con il VMS, passarono poi a Linux. Però avevano i loro motivi: c’era l’idea di avviare un filone di ricerca dedicato ai Sistemi Operativi. Il progetto si arenò perché essenzialmente stavano riscrivendo Unix. Inventare un sistema operativo non è qualcosa di banale. La stessa Microsoft, sotto sotto, ha ancora il nucleo originale. Mi è difficile pensare a un Windows XP o Vista o 7 che funzionasse cancellando kernel32. Secondo me non funzionerebbe più nulla! Alla fine, si arriva sempre là. A mio parere, più strati metti più la questione diventa complicata. Nel mio studio ho un Windows 7 che provvederò ben presto a formattare per mettere di nuovo Windows XP.
S.- Come mai?
P. - Windows Vista è un sistema operativo che gira per sé stesso. E’ autoreferenziato! A confronto, il vecchio e tanto vituperato XP è molto più leggero e, soprattutto, rodato. Non ho mai avuto problemi con Windows XP, eseguendo gli aggiornamenti costantemente. E’ chiaro che se invece l’abbandoni a se stesso, il sistema si deteriora rapidamente. Tornando a Vista, è inammissibile che un sistema operativo richieda 1,4 Gb solo per lui, accendendo una serie pressocché infinita di servizi essenziali solo per i programmatori della Microsoft e che non ci è dato di conoscere! Sul mio XP ho un bel po’ di roba e il sistema gira occupando 400 Mb di memoria, su una macchina con 2 Gb di RAM. Il vecchio VAX aveva 40 MB di memoria e serviva più di 100 utenti. E’ vero che non era appesantito dalla grafica. Proprio la grafica ha giocato a svantaggio della Microsoft: non vedo il motivo per l’esistenza di Aero. Avere il bordo della finestra semitrasparente? Qual è il motivo? Esiste una casa di software che ti consente di simulare sotto XP la grafica di Vista. Funziona benissimo ed occupa poca memoria. L’ho comprato per sfizio personale: 25 dollari!
S. Torniamo al periodo in cui è stata portata la Rete nel dipartimento.
P. Si. Fu il prof. Romano, che al tempo era la nostra interfaccia con la sede di Napoli dell’Istituto Nazionale di Fisica Nucleare, a farci capire che eravamo molto arretrati da questo punto di vista. E quindi portammo la rete DECNET a Salerno che consentiva di collegarci al resto del mondo. E da lì cominciò il tormentone della posta elettronica! Tutto era gestito da una sola macchina. La DECNET era una buona rete proprietaria. La DECNET fu poi soppiantata dal protocollo TCP/IP che divenne uno standard a cui non potevi più sottrarti…
S. Cosa c’era sul DECNET? Posta elettronica, talk…
O. Si, c’era il Phone che era un programma di talk, Posta elettronica, Telnet, FTP…C’era tutto quello che si trovava in TCP/IP ma non era TCP/IP. Aveva delle buone interfacce, però, che ti consentivano molto semplicemente di colloquiare con macchine Unix, Ciò era possibile installando degli appositi moduli addizionali. Col DECNET quindi non eri isolato. Alla fine migrammo anche noi comunque al TCP/IP. Fortunatamente la Digital aveva allestito già tutto per il porting. Abbandonammo DECNET non senza qualche dispiacere. Se ricordi, la macchina VAX di Napoli si chiamava VAXNA1: se dal tuo terminale a Salerno digitavi VAXNA1:: potevi, dopo aver inserito username e password, direttamente collegarti a quella macchina senza bisogno del Telnet . Quindi DECNET aveva un suo Telnet che probabilmente era molto più sicuro del suo concorrente. Sotto DECNET si accedeva alla posta mediante il comando mail…Se poi vai a vedere, la struttura di Outlook è stata copiata pari pari da quella di DECMAIL.
S. Se non sbaglio uno dei progettisti della DIGITAL è finito alla Microsoft…
P. Non un progettista qualsiasi, ma il progettista più importante della Digital: David Cutler che abbandonò polemicamente l’azienda per andare a creare Windows NT alla Microsoft. Già scrivere un sistema operativo è un’avventura, ma scriverne addirittura 3 come ha fatto lui è qualcosa di eccezionale. Lui partì con il sistema operativo che girava sulle macchine precedenti il PDP, poi ideò il VMS per i PDP e infine Windows NT. Le malelingue dicono che la sigla WNT soddisfi l ‘equazione: WNT=VMS+1. Ovviamente Cutler portò con sé tutto il know-how della Digital e le fondamenta di Windows 2000 nascono proprio da quel mondo.
S. Vogliamo ricordare che fine ha fatto la Digital?
P. La Digital è declinata rapidamente… che peccato! Prima fui acquisita dalla Compaq che a suo volta è sparita nella HP. Una fine ingloriosa dovuta all’ostinazione di non mettersi al passo coi tempi e dei Personal Computer. E’ un vero peccato perché i prodotti della Digital erano prodotti solidi che raramente davano problemi.
S. Cosa ricordi del periodo in cui esplose Internet?
P. - Le novità si susseguivano giorno dopo giorno. Ricordo che installammo qui a Salerno la prima versione di Mosaic su diversi personal computer. Certo, poi, con Netscape la nostra vita cambiò da così a così. Per la prima volta avevi a portata di mano tutto le informazioni di cui avevi bisogno! Spuntarono fuori i primi motori di Ricerca: Altavista, sviluppato dalla Digital, che girava sul Mosaic per VAX. Una novità essenziale fu che potevi scaricare software dalla rete in maniera molto semplice. E inevitabilmente i mainframe andarono decadendo: le richieste dei clienti andarono aumentando molto rapidamente e quelle macchine grosse non furono più in grado di soddisfarle. Fui veramente dispiaciuto quando spegnemmo il VAX: ma oramai la spesa di manutenzione era diventata inaccettabile.
S. Ma nel dipartimento di Fisica quanti utenti c’erano su queste macchine ( a parte gli studenti smanettoni)?
P. Prima dell’avvento della posta elettronica davvero pochi: solo quelli che facevano calcolo numerico. E ben pochi erano esperti di compilatori. Quasi nessuno sapeva dell’esistenza di f2c o dei compilatori GNU.
Poi non c’erano i print server: i plotter e le stampanti risiedevano nel centro di calcolo dove spesso c’erano file di persone che dovevano stampare file. Poi, cambiò tutto con i personal computer…e fu subito chiaro qual era la tendenza generale: se potevi copiare un software era molto meglio che acquistarlo. Anzi, il loro rammarico era che non si potesse copiare l’hardware! Io sono sempre stato dell’avviso contrario: i software vanno acquistati. Innanzitutto c’è gente che ci lavora sopra e che di deve mangiare e pagare i conti. Certe volte, sicuramente, i prezzi sono eccessivi ma quando parliamo di piccoli programmi di utility non capisco perché uno non debba comprarli. Cosa accadrebbe se in generale nel mondo la gente non venisse pagata per il lavoro che fa?
S. io non ho mai capito perché c’è gente che per fare grafica semplice ha bisogno di scaricare l’ultima versione craccata di Photoshop o altri software sofisticatissimi
P. Sicuramente. Molte volte la scelta di un software non è commensurata all’uso che se ne vuole fare. Si finisce quindi per usare solo una minima parte delle funzionalità di un programma. Quante persone sono a conoscenza del fatto che Word sia programmabile? Si usa quel software come se fosse Notepad, ne più ne meno.
S. Una curiosità…Se tu fossi responsabile in una sede di una pubblica amministrazione della scelta dell’hardware e del software come spenderesti i soldi del tuo budget? Compreresti licenze Microsoft o opteresti per software e sistema operativo libero?
P. Mi sono già trovato in una situazione del genere. In una commissione per la digitalizzazione della Provincia di Avellino. Lì optammo per una soluzione economica. Un po’ perché come dicevamo prima si tratta di prodotti sprecati per personale che non è disposto ad imparare. La soluzione ideale, per me, sarebbe predisporre un mainframe a cui accedere via terminale per un numero limitato di operazioni. Fornire al personale una macchina potente che costi 500-600 € è per me è un grande spreco. Credo che basti un editor ragionevole, ad esempio Notepad++. Ripeto: anche un prodotto come Open Office sarebbe sprecato in mondo dove i corsi di aggiornamento professionale non sortiscono alcun effetto. In definitiva, spenderei i soldi del budget per l’acquisto di una buona macchina server (5000-6000 €). Gli utenti si collegherebbero via terminale al server accedendo a pochi programmi di utility gratuiti. Open Office si può tranquillamente usare in multi-utenza. Poi completerei l’infrastruttura con una macchina di backup e, tornando agli utenti, eliminerei ogni browser…
S. (Risata)
P. Se volete navigare, installate una ADSL a casa vostra!
S. Tu hai anche avuto a che fare con i linguaggi LISP
P. Si. Sempre ai tempi del VAX, acquistammo per una cifra astronomica Maxima. Maxima era un software per la manipolazione di espressioni numeriche e simboliche, interamente scritto in LISP. Pensa che oggi è distribuito gratuitamente! Te lo consiglio perché non ha nulla da invidiare a MATHEMATICA. Ho installato e lavorato con un compilatore LISP ma l’ho trovato molto….ispido. Non è una cosa che impari velocemente. A cominciare dalla struttura sintattica che è davvero fuori dal comune: tutte quelle parentesi ti fanno impazzire! E’ un altro mondo di programmazione: c’è chi separa l’universo della Programmazione in linguaggi LISP e non LISP!
(N.B. Maxima si può scaricare al seguente indirizzo)
S. – Che percorso formativo suggerisci a chi si avvicina al mondo della programmazione…
P. - Comincerei col Fortran, come primo impatto. E’ un come il Bridge. C’è gente che vuole subito imparare il sistema artificiale. Finché non comprendi i limiti del sistema naturale, non puoi apprendere qualcosa che nasce per superarlo. Non puoi onestamente iniziare con un sofisticato linguaggio ad oggetti sotto .NET. L’ambiente di lavoro è complesso e occorre un corso solo per apprenderlo. Non sai come aprire o creare un file, non sai come viene prodotto un eseguibile. Invece, devi avere un editor, scrivere il sorgente, aprire una linea di comando, compilare il codice sorgente e linkarlo allo opportune librerie. Non bisogna cedere alle finezze estetiche: se devi scrivere un programma che esegue un calcolo o una simulazione Montecarlo, non c’è necessità di utilizzare un linguaggio ad oggetti. Meglio il Fortran. Il motivo? Velocità e semplicità.
S. Ok, direi che possiamo fermarci qui. Nel prossimo incontro parleremo della tua grande passione, il VB6! Grazie e alla prossima!
P. Certo! Grazie a te e alla prossima!
Il Progetto Colt mette a disposizione dei suoi utenti un insieme di Librerie Open Source per il calcolo numerico. Il codice è scritto in Java e l’ultima release risale ad Agosto 2010. I campi di interesse sono i seguenti:
· Templated Lists and Maps
· Templated Multi-dimensional matrices
· Linear Algebra
· Histogramming
· Mathematics
· Statistics
· Random Numbers and Random Sampling
· Parallel & Concurrent programming
Navigando su Internet, ho scoperto che gran parte del codice sorgente Java è stato tradotto in C# sotto il framework .NET.
Purtroppo non esiste un sito web di riferimento e tutto questo codice è inserito in package più “generale” che ho scaricato al seguente indirizzo . Spero di non aver commesso alcun crimine per aver raccolto tutta la sezione scientifica in un unico progetto .NET che ho allegato all’articolo.
Vediamo un semplice utilizzo di questa libreria.
In teoria della probabilità la distribuzione di Poisson (o Poissoniana) è una distribuzione di probabilità discreta che esprime le probabilità per il numero di eventi che si verificano successivamente ed indipendentemente in un dato intervallo di tempo, sapendo che mediamente se ne verifica un numero Lambda.
La distribuzione di Poisson trova applicazione nello studio dei cosiddetti processi di Poisson, rappresentabili come eventi casuali, indipendenti tra loro e distribuiti uniformemente nel tempo.
Un'applicazione pratica famosa nella storia è quella connessa agli studi del dott. von Bortkewitsch sulle morti per calci di cavalli nell'esercito prussiano alla fine del XIX secolo! Esempi più concreti possono essere il numero di telefonate in arrivo ad un centralino, i guasti che si verificano in un apparato complesso formato da molti componenti indipendenti, i difetti in una striscia di materiale, etc.
Per definizione,
Dove Lambda è il numero medio di eventi per intervallo di tempo. Tornando ai nostri esempi, se in un’ora il centralino riceve in media 8 telefonate, la probabilità di riceverne 4 nello stesso intervallo di tempo è data dal valore P(4), dove Lambda = 8.
Supponiamo di aver importato la libreria in un nostro progetto. Il codice mostrato in figura mostra come calcolare la probabilità richiesta. L’istanza dell’oggetto Poisson viene inizializzata col valore medio noto, dopodiché il metodo pdf restituisce per un argomento x il valore della distribuzione di probabilità associata. Qualora siate interessati alla funzione cumulativa, basta invece utilizzare il metodo cdf.
La libreria contiene anche distribuzioni molto complesse come la temibile funzione Zeta, la Breit Wigner, la funzione Gamma e molte altre. Per gli appassionati della generazione di numeri random (ricordiamo la spinosa questione dell’assegnazione del premio agli incontri del gruppo DOTNETCAMPANIA!), la libreria offre generatori molto sofisticati quali DRAND e MersenneTwister. Leggete però attentamente la documentazione per essere sicuri di utlizzarli correttamente.
A tutti coloro che invece sono solo interessati al linguaggio C#, segnalo tutto il codice accessorio utilizzato nella libreria, ad esempio la costruzione dei Comparatori specializzati per i diversi tipi.
Concludo riportando le condizioni di utilizzo del codice contenuto nella libreria.
Ecco il rar della soluzione:
Nello scorso post vi ho raccontato di un problema di visualizzazione nei dati estratti dal database Yahoo! GeoPlanet appartenenti ad entità geografiche cinesi (e giapponesi).
Ho risolto il problema importando nuovamente i dati mediante il DTS di SQL Server 2008 ma dando stavolta un’occhiata più approfondita alle opzioni.
Mi riferisco in particolare al menù a tendina Tabella Codici. L’opzione di default è 1252 – ANSI (Latino I). Se scorrete le decine di opzioni disponibili, troverete il valore che fa al caso nostro: 65001 (UTF-8). Una volta terminata l’importazione, i dati vengono visualizzati in maniera corretta (almeno spero, non conoscendo le lingue asiatiche!!!)
In questo post vedremo un esempio di utilizzo del database GeoPlanet presentato in precedenza. Supponiamo di avere importato i file testuali nel nostro database (nel mio caso SQL Server 2008).
Partiamo da una richiesta che ci fornisca tutte le entità geografiche italiane. Eseguiamo una query sulla tabella Geoplanet_places imponendo che il codice ISO dell’entità sia uguale ad “IT” (L’elenco dei codici ISO può essere trovato al seguente indirizzo).
La query ci fornisce come risultato ben 55696 entità. Cosa abbiamo trovato esattamente? Il campo Place_Type ci chiarisce le idee a riguardo.
Il PlaceType “State” ci fornisce la regione in cui si trova la località. A questo punto possiamo eseguire una nuova ricerca che ci fornisca le località figlie della regione “Campania” (ID=7153333).
Notiamo la comparsa delle Province (PlaceType= County). Nella documentazione ufficiale, Zone viene così descritto: one - Metropolitan Statistical Area (MSA), Telephone Area Code. In più compare un parco Nazionale che viene associato a tutta la regione e non alla singola Provincia.
Troviamo ora le entità che hanno come genitore la provincia di Napoli. Sono registrate 123 entità appartenenti alle seguenti Place_Type: Codici Postali (ZIP), Comuni (LocalAdmin), Isole (Island), Parchi (LandFeature) e Frazioni (Town). I comuni trovati sono 92, in accordo con quanto indicato dal sito web ufficiale dei Comuni Italiani. Se eseguiamo una query imponendo che il Parent_ID sia Napoli troviamo il seguente risultato:
In realtà, per indagare più a fondo sul Comune di Napoli occorre interrogare la tabella GeoPlanet_adjacenses che contiene tutti gli accoppiamenti geografici di coppie di entità. Napoli ha 14 comuni confinanti (o di prima corona). Una vista può aiutarci a leggere meglio la lista risultante.
La tabella Geoplanet_aliases, infine, fornisce per ogni entità una serie di alias in varie lingue.
Vediamo un’applicazione banale. Yahoo offre un Web Service di previsioni del tempo. Invece di inserire una stringa testuale nella query di ricerca col nome della località, basta inserirne il WOEID:
http://weather.yahooapis.com/forecastrss?w=20076932
Se inserite invece la WOEID della vostra località nella seguente stringa
http://www.geomojo.org/cgi-bin/getaltitude.cgi?woeid=20076932
ne troverete le coordinate geografiche e l’altitudine in metri rispetto al livello del mare!
Un servizio più sofisticato (per smanettoni di ordine superiore) è il PlaceFinder di Yahoo.
In conclusione, credo che possa far molto comodo avere a propria esclusiva disposizione un database geografico ufficiale da cui trarre le informazioni principali per poi agganciarsi a servizi web offerti sulla rete. Non possiamo prevedere se il WOEID diventerà uno standard universale nei prossimi anni o scomparirà miseramente ma al momento io lo aggiungerei alla cassetta degli attrezzi del Programmatore moderno!
P.S. Cosa succede con località aventi nomi con caratteri non latini? Per fare questo ho creato una semplice pagina web con una griglia collegata al database tramite sqldatasource.
Mentre le località arabe vengono rese bene quelle cinesi danno più problemi.
Giocando con i settaggi di Firefox, il mio browser predefinito, si può arrivare a un risultato migliore ma è evidente che manca ancora qualcosa. Nella documentazione ufficiale di Yahoo non è specificato che “Cinese” abbiano utilizzato. Se qualcuno di voi ha affrontato e risolto il problema, non esitate a lasciare un commento.
Ho letto un articolo molto interessante sul censimento indiano che è partito in questi giorni. Lì troverete tutti i dettagli affascinanti di questo progetto visionario.
“… il governo ha deciso di non limitarsi a contare la popolazione indiana, ma di assegnare a ogni singolo cittadino sopra i quindici anni un Unique Identity Number (UIN), un numero identificativo univoco”.
Immagino che gli amanti dei database avranno avuto un fremito ad apprendere questo dettaglio. Io ho subito associato la notizia alla meravigliosa serie TV degli anni 60 “The Prisoner” nella quale un ex-agente segreto del governo britannico, immediatamente dopo le sue dimissioni, viene imprigionato in un piccolo villaggio con abitazioni e monumenti in stile mediterraneo, situato in una località sconosciuta. Da quel momento tutti si rivolgono a lui chiamandolo Numero 6
C’è da chiedersi come potranno mai riuscire gli Indiani a realizzare questa impresa monumentale. Ebbene, il governo Indiano non ha badato a spese.
“…Per farlo ha reclutato alcuni dei migliori ingegneri e guru informatici indiani sparsi in giro per il mondo, tra cui il co-fondatore del servizio di foto online Snapfish e molti dipendenti di Google, Yahoo! e Intel. Il meccanismo è questo: per ogni cittadino si raccolgono non solo le classiche informazioni anagrafiche (nome, data di nascita, sesso, residenza, status familiare, occupazione), ma anche foto, impronte digitali e scansioni dell’iride. Tutte le informazioni sono poi archiviate in un enorme database centrale e lì associate a un numero identificativo di dodici cifre che viene poi spedito per posta. Passaporti, carte d’identità, patenti di guida, ration cards, tutto dovrà poi avere quelle dodici cifre stampate sopra o incorporate con un chip elettronico.”
Vedremo nei prossimi anni come andrà a finire questa storia. Intanto, il coinvolgimento di Yahoo! mi ha fatto ricordare un altro progetto dove si torna sul concetto di Unique Identifiers.
Yahoo! GeoPlanet™ Data
Yahoo! GeoPlanet helps bridge the gap between the real and virtual worlds by providing an open, permanent, and intelligent infrastructure for geo-referencing data on the Internet. This page provides open access to the underlying data under a Creative Commons Attribution license so that you can incorporate WOEIDs and the GeoPlanet hierarchy into your own application
In pratica, Yahoo! GeoPlanet è una risorsa che raccoglie tutte le località “geo-permanenti” sul pianeta Terra. Esso fornisce alla comunità di sviluppatori di software geografici un vocabolario e una grammatica per descrivere la geografia del mondo in maniera non equivoca, permanente e indipendente dai linguaggi. Le entità geografica fornite da Yahoo! GeoPlanet sono referenziate da un identifier a 32-bit: the Where On Earth ID (WOEID). I WOEID sono unici, non ripetitivi e, una volta assegnati, non vengono mai cambiati o riciclati. Può accadere che un WOEID venga deprecato e, in tal caso, viene mappato al suo successore o al suo WOEID parente.
Yahoo! GeoPlanet è un Web service REST, accessibile alla seguente URI:
http://where.yahooapis.com/v1[parameters]
Ci sono diversi progetti che utilizzano questo web service; un esempio è Twitter. Con un po’ di ricerche sul Web, troverete anche come legare in maniera semplice diversi servizi offerti dalla stessa Yahoo che utilizzano il WOEID.
Stabilito ciò, Yahoo! mette anche a disposizione gratuitamente il database sotto forma di file testuali.
I file sono i seguenti:
- geoplanet_places_[version].tsv: the WOEID, the placename, and the WOEID of its parent entity
- geoplanet_aliases_[version].tsv: alternate names in multiple languages indexed against the WOEID
- geoplanet_adjacencies_[version].tsv: the entities neighboring each WOEID
- geoplanet_changes_[version].tsv: the list of removed WOEIDs and their replacement WOEID mappings
Geoplanet_places è la tabella principale. Essa contiene i seguenti campi:
* WOE_ID - primary "place" key
* ISO - ISO 3166-1 country/territory code
* Name - preferred local language or english place name
* Language - ISO 639-2(b) language code
* PlaceType - code indicating place class
* Parent_ID - WOEID of direct parent feature
Ho importato i file sotto SQL Server 2008 e fatto qualche test. Per motivi di spazio, tornerò a parlare dei risultati ottenuti nel prossimo post.
Cosa occorre fare quando il fallimento di un progetto, di un’idea, diventa chiaro e inevitabile? Non ho una risposta certa ma sicuramente non bisogna seguire l’esempio di Donald Crowhurst.
![logo[1]](http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Blogs.Components.WeblogFiles/salvatore.metablogapi/3051.logo1_5F00_thumb_5F00_5FF667F7.png "logo[1]")
Comic Vine è un database contenente informazioni sui fumetti pubblicati nel mondo. I dati, inseriti da una numerosa comunità di appassionati, forniscono ai collezionisti tutte le informazioni necessarie per gestire le loro raccolte.
Il database è disponibile per le ricerche on-line ma oggi voglio parlarvi del servizio di API messe a disposizione di uno sviluppatore software. Comic Vine, mediante un web service REST, restituisce, sotto forma di file xml, tutte le informazioni richieste al database mediante una query. L’utente però dovrà prima aver richiesto una chiave per la consultazione.
La documentazione non è a mio avviso chiarissima e quindi ho pensato di mostrare qualche esempio di costruzione di query e un semplice codice VB.NET per eseguire la richiesta.
Supponiamo di voler estrarre informazioni relative al fumetto Topolino pubblicato in Italia. Anzitutto occorre conoscere l’ID del fumetto nel database. La query di richiesta è la seguente:
queryString = "http://api.comicvine.com/search/?api_key=" +
ChiaveFornitaDaComicVine +
"&format=xml&resources=volume&field_list=name,start_year,id&query=Topolino"
Come eseguiamo la richiesta? Ecco un esempio minimo di codice:
Eseguendo questo codice si ottiene il seguente output in formato xml:
Il fumetto Topolino ha un id = 1313. Il passo successivo è capire quanti e quali issues (ossia singoli giornaletti) sono disponibili nel database. La query da inserire nella richiesta è:
queryString = "http://api.comicvine.com/volume/1313/?api_key=" +
ChiaveFornitaDaComicVine + "&format=xml&field_list = issues"
Eseguendola con lo stesso codice visto in precedenza si ottiene in output un file xml piuttosto voluminoso (circa 600 kb) che contiene una lista di 2848 singoli numeri. Ecco il dettaglio per un singolo numero che ci fornisce il suo id:
Noto l’id di un singolo numero possiamo interrogare il database per ottenere tutti i suoi dettagli. La query sarà la seguente:
queryString = "http://api.comicvine.com/issue/233096/?api_key=" +
ChiaveFornitaDaComicVine + "&format=xml"
![1376959-it_tl_2856a_001_super[1]](http://dotnetcampania.org/cfs-file.ashx/__key/CommunityServer.Blogs.Components.WeblogFiles/salvatore.metablogapi/0456.1376959it_5F00_tl_5F00_2856a_5F00_001_5F00_super1_5F00_thumb_5F00_56BA2CB6.jpg "1376959-it_tl_2856a_001_super[1]")
Il vero appassionato a questo punto potrà leccarsi i baffi perché in output avrà a disposizione la copertina in varie dimensioni e l’elenco di tutti i personaggi che appaiono nel numero selezionato. Ecco ad esempio Zio Paperone:
Noto l’ID del personaggio potrete eseguire una nuova query per conoscere tutti i suoi dettagli ed estrarre le sue apparizioni nel fumetto “Topolino”! Lascio a voi il compito di costruire la query necessaria: attenzione però che il file di output in questo caso sarà piuttosto voluminoso.
Comic Vine mette a disposizione dell’appassionato il suo database gratuitamente. Ovviamente il discorso cambia qualora voleste usarlo in un applicativo commerciale. Le API sono semplici e con poche righe di codice è possibile estrarre un mare di informazioni periodicamente aggiornate da una comunità di collezionisti e fan.
“Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the Universe trying to produce bigger and better idiots. So far, the Universe is winning."
(Rick Cook)
Grazie a un mio amico (che conoscerete fra un po’ in una delle mie chiacchierate) che si occupa di queste cose ho scoperto che esiste un prodotto freeware specializzato per il calcolo statistico.
R è un ambiente di lavoro che consente di lavorare interattivamente sui dati e visualizzare graficamente i risultati delle analisi. Il codice sorgente è a disposizione di tutti e compila sotto Linux, UNIX, Windows e MacOS. Io ho installato l’eseguibile per piattaforma Windows a 64 bit senza alcun problema. Il progetto R, poi, comprende anche una comunità di sviluppatori, una rivista di statistica e un bel po’ di mailing list. Si tratta di una comunità numerosa e in fervente attività.
Abbiamo visto la console interattiva anche con PAW. E’ inevitabile che il suo uso necessiti di una fase di apprendimento ma alla lunga la sua enorme flessibilità non può che produrre risultati migliori rispetto ad un’interfaccia “bloccata” dove si utilizzano menù e finestre di settaggi.
Io ho seguito questo tutorial riproducendone senza difficoltà tutti i passi. A essere onesti, è singolare che si debba indicare via menù la directory di lavoro e poi caricare il file via console piuttosto che avere un menù di caricamento diretto del file di input: è un sintomo di come l’interfaccia non sia stata progettata con grande attenzione. Tuttavia basta vedere il dettaglio dei risultati di una semplice regressione lineare per rimanere stupiti.
Il programma è estendibile mediante l’installazione di moduli esterni (ad oggi sono più di 2500) ed esiste anche un manuale per scrivere un proprio modulo. Esistono dei moduli per collegarsi a database come Oracle, MySql, PostgreSQL,SQLite. Non mi pare che esista un modulo per collegarsi a SQL Server ma ne esiste uno per JDBC.
Per le mie piccole analisi statistiche credo che userò questo software che,a differenza di PAW, si fonda su una comunità di programmatori in continua evoluzione.
Voglio poi esprimere il mio rammarico sul fatto che non esista nulla di simile sviluppato dalla Microsoft sotto .NET. Il collegamento ai database sarebbe immediato con motori di querying flessibili e veloci, potremmo scegliere il linguaggio con cui scrivere le istruzioni interattive e avere a disposizione le DirectX per la rappresentazione grafica. Possibile che dipenda tutto dal mercato?
La prima chiacchierata di questa serie è con il Cristiano Bozza, validissimo ricercatore presso l’Università di Salerno con cui ho avuto il piacere di lavorare a fine anni 90 fino al 2002 circa. Il gruppo di Fisica delle Emulsioni di Salerno, fondato dal Prof. Giorgio Romano con la collaborazione del Prof. Pino Grella (che conoscerete presto), ha il merito di aver fatto una scelta di campo ben precisa e di averla mantenuta per tutti questi anni: l’uso delle tecnologie Microsoft nell’ambito della Fisica Sperimentale. Grazie a loro ho scoperto il Visual Basic, C#, il Visual Studio, i database relazionali, la MSDN, i manuali della Wrox, etc etc. Basta ciò, dunque, per capire che importanza abbia avuto questo gruppo di persone nella mia vita.
***************************************************
S. – Partiamo proprio da zero. Una rapida presentazione e poi le tue origini informatiche che risalgono, immagino, agli anni 80.
K. – Salve! Sono Cristiano Bozza, classe 1972. Attualmente Ricercatore in Fisica presso l’Università degli Studi di Salerno. Le mie origini informatiche risalgono al 1982 con un TI-99/4A della Texas Instruments che si programmava in Microsoft TI-Basic (un dialetto del BASIC implementato dalla Texas Instruments) e successivamente in TI Extended Basic. Come tutti i ragazzini di 9-10 anni di quel periodo, la mia aspirazione era quella di creare videogiochi. Dopo circa 2 anni sono migrato all’ Assembler e come risultato ho eseguito il porting di qualche gioco da bar tra cui Q*Bert che conservo ancora su qualche audio cassetta.
S. Nell’82 eri alle scuole medie?
K. Nel passaggio tra le scuole elementari e quelle medie.
S. Caspita! Ed eri completamente autodidatta?
K. Sì. Fortunatamente i computer di quell’epoca costringevano a programmare. Potevi comprare dei giochi su cartucce ma il prezzo tipico era sulle 100000 lire da comparare alle 700000 del prezzo del computer stesso.
S. Ricordiamo le caratteristiche di questo PC del 1982…
K. Sul TI-99 girava un processore a 16 bit TMS9900 a 3 Mhz con una struttura simile ai Motorola perché aveva i registri software. C’era un banco di registri che altro non erano che mapping su indirizzi di memoria. Non c’era accumulatore ma tutti i calcoli venivano eseguiti sulla memoria. I registri sono solo dei nomi di comodo che tu assegni a un’area di memoria. Non aveva stack per cui i branch venivano realizzati mettendo nel registro 11 l’indirizzo di ritorno della nuova funzione. Poi era possibile cambiare il workspace passando a delle variabili locali cambiando, contestualmente al salto, anche il set dei registri. Nei registri 12 e 13 c’erano i puntatori alle aree di memoria del programma chiamato e in questo modo potevi passare dei parametri. Il processore grafico TMS9918A ha avuto applicazione negli MSX.
Tornando al TI-99, era una macchina analoga al Commodore 64 che però uscì sul mercato solo nell’anno seguente. Un’altra fortuna fu che il TI99 fu ritirato dal mercato per scarsa fortuna commerciale e per la pessima politica della Texas Instruments che pretendeva di avere lo sfruttamento esclusivo di tutto il software sviluppato sotto la sua piattaforma
S. La Texas Instruments poi è completamente sparita dal mercato dei PC/home computers, no?
K. Sì, è rimasta essenzialmente come produttrice di semiconduttori. Diciamo che il TI-99 era una macchina particolarmente difficile da programmare. Mentre il Commodore 64 aveva una mappa di memoria unica che ti consentiva di accedere a tutti i 64K in un colpo solo, sul TI-99 avevi 16K di memoria VDP (e potevi utilizzarne solo 13) e i programmi erano residenti sull’area video! (sembra un’assurdità!) C’erano 8K di ROM che in realtà ospitavano solo il codice che serviva a leggere la GROM. La GROM era la cosiddetta ROM grafica auto-incrementante che conteneva i comandi ad alto livello quali ad esempio “Traccia una Linea” che poi venivano utilizzati dall’interprete BASIC. Tutte le cartucce (“Solid State Software”), invece, erano programmate in Assembler. Il computer aveva di vera e propria RAM solo 300 B. Potevi poi acquistare un’espansione di memoria da 32 KB, divisa in due banchi: uno da 24 e uno da 8! In più avevi la Mini memory, 4K addizionali per la bellezza totale di 36 K in cui dovevi mettere un intero gioco ( e oggi ci metti solo un’icona in quello spazio!).
(N.B.: In rete esiste un emulatore del TI-99. In allegato all’articolo troverete un video contenente una mini-sessione sull’emulatore)
S. Ok, quindi che alla tenera età di 11 anni sei passato all’Assembler. A quei tempi non c’era Internet. Come poteva studiare queste cose il ragazzo medio?
K. Fotocopiava le 400 pagine del manuale del TI-99 (che ancora conservo) e poi cominciava a fare prove su prove. Passavano così le estati, con sessioni lunghe anche 14 ore!
S. Il TI-99 era una macchina solida?
K. Si, era proprio un’altra classe di elettronica. Tra l’altro, funziona ancora a differenza di computer più recenti che si sono bruciati! L’unico problema era la vista dato che lavoravi su un monitor da 11” a 20 cm dalla faccia!
S. Le tue prime opere firmate sono state dunque delle con versioni di giochi.
K. Si. Il primo è stato Q*Bert che venne proprio bene! Poi ho ideato e scritto un gioco di corse d’auto. Il numero massimo di giocatori era 4: due col joystick e due con la tastiera. La partita era configurabile tramite un pezzo di codice in Extended Basic. Si potevano scegliere i colori delle auto e il tipo di gomme da montare! Avevo implementato un modello di usura gomme e quindi era necessario tornare ai box per il cambio. La preparazione e la premiazione erano scritte in Basic mentre tutta la fase di gioco vero e proprio era in Assembler. Per la creazione della pista implementai un algoritmo di riempimento di una figura chiusa senza avere uno stack ma implementandone uno. E’ un problema classico di grafica 2D e la soluzione viene molto bene se hai uno stack; se non ce l’hai devi inventartene uno. In effetti sono sempre stato molto interessato alla grafica e alle alte prestazioni. Poi sono passato allo studio della prospettiva…Devo dire che è stata colpa di Piero Angela! In quel tempo c’era la sigla di Quark con la grafica wire frame. Li è nata la curiosità….
S. Andiamo avanti agli anni dell’Università. Tu sei un ingegnere…
K, Si, ingegnere meccanico. Ricordo che a quei tempi comprai un computer compatibile IBM, con uno dei primi processori 486 DX2 a 50 Mhz.
S. Caspita! Quelli col famoso coprocessore matematico integrato!
K. Si. Computer pagato ben 3 milioni e mezzo di lire!. Ricordo che al negozio, col PC ancora nello scatolo, passò uno che mi chiese: “è il 50 o il 60?” Io risposi: “il 50!” e lui; “Ah, è quello vecchio!”; e io “ma come, è nello scatolo!”
S. Sì, a quei tempi era cosi! Parliamo dell’anno?
K. 1993.
S. Quindi il sistema operativo era un Windows 3.1
K.Si. DOS 5.0 e poi 6.2
S Immagino che per te si siano aperti orizzonti sconfinati! Che compilatori c’erano all’epoca?
K. Il TurboPascal, il Turbo C (avevo apprezzato molto la possibilità di mettere l’Assembler inline). Il divertimento mio e dei miei amici era quello di scrivere chiamate TSR (Terminate and Stay Resident) che restituivano il controllo al DOS come se il programma fosse terminato ma in realtà esso si trovava ancora in memoria. I TSR servivano per creare utilities e virus (ma non ho mai scritto un virus, li odio profondamente: li ritengo immorali). Visto che Internet ancora non c’era, ricordo di aver litigato con un mio amico che si rifiutò di farmi fotocopiare il manuale del processore 386. Il problema è che erano libri che non potevi neanche comprare! Le librerie non sapevano neppure cosa ordinare! Dovevi un po’ arrangiarti…ad esempio per scoprire come si elaborava la grafica in risoluzione 800x600, ho eseguito il debug via linea di comando della sequenza di avviamento di Tristan, un Flipper, seguendo tutte le chiamate ad interrupt. Un reverse engineering che allora era pane quotidiano!
Dopodiché ho cominciato a lavorare sotto Windows 3.1 scontrandomi subito con i problemi ben noti all’epoca: i 16 bit e la mappa della memoria con selettore e segmento. In realtà esiste ancora oggi ma un po’ più sofisticata. Molti non lo sanno più ma i computer IBM compatibili continuano a funzionare quasi allo stesso modo (in realtà i selettori di segmento sono degenerati ampiamente, e il sistema operativo ti nasconde molte cose, occupandosene direttamente).
“Meglio non saperle queste cose! E all’università? Hai seguito corsi di Informatica?”
“Si. L’unico buon corso che abbia frequentato è stato quello di Programmazione tenuto dalla Professoressa Wilma Russo. Una cosa che mi mancava come cultura di programmazione era un approccio organico alle reti logiche e alla programmazione strutturata. Avevo sempre scritto tutto io, inventando a volte l’acqua calda. Avere invece una panoramica sugli algoritmi e sulle problematiche più classiche aiuta moltissimo. Dopo ho cominciato a lavorare col C e il C++.
“Quindi il C++ l’hai scoperto con l’università”
“Sì. Mi ci sono buttato a pesce! Mi piaceva molto la possibilità di utilizzare un linguaggio ad alto livello che però di consentisse di controllare anche il basso livello. Il passaggio al C++ mi è stato utile quando da sono entrato nel gruppo di Salerno di Emulsioni Nucleari (Fisica Subnucleare) fondato dal Prof. Giorgio Romano. Infatti la prima cosa che mi han chiesto è stata scrivere un’interfaccia grafica per una scheda di acquisizione Matrox Pulsar e acquisire immagini da una telecamera ad alta risoluzione. L’idea all’epoca era quello di creare un sistema semi-automatico per la misura di tracce di particelle in emulsioni nucleari. Quindi alla fine, tutta la cultura di grafica e di approccio al basso livello mi è servita immediatamente. In effetti, la routine di blob recognition che scrissi nel 1996, con poche modifiche, è quella che gira ancora oggi sul nostro sistema di acquisizione ed è scritta in Assembler: c’è un pezzo di codice in C con un bell’ASM all’inizio e uno alla fine e in mezzo è tutto Assembler!
 |
Nel frattempo ho scoperto altri linguaggi (SQL, HTML, Shockwave) ma la cosa fondamentale è stata l’introduzione del C#. Io considero il C++ un qualcosa di incompleto perché ha problemi di portabilità. Purtroppo il modello di oggetto del C++ è inconsistente, nel senso che di fatto tutti i compilatori per implementare i metodi di un oggetto usano una serie di funzioni che hanno in molti casi la decorazione del nome del C (con l’underscore davanti). Quindi i compilatori continuano ad essere essenzialmente compilatori C. Inoltre, per via della storia dei puntatori, alla fine si può sempre mettere le mani su un oggetto. Si possono certo usare metodi privati ma alla fine, se uno vuole, ci mette poco a capire come un oggetto è veramente fatto. Poi sanno tutti che la probabilità di produrre bug con puntatori che vanno in giro per la memoria è alta. Si possono utilizzare librerie di smart-pointer: ne ho scritte anche io ma alla fine si tratta sempre di estensione di sintassi. Prima o poi qualcosa ti sfugge, soprattutto in progetti grossi, e soprattutto quando poche persone devono occuparsi di milioni di linee di codice. Invece, ciò che mi ha attratto subito del C# è stata la possibilità di poter produrre codice intrinsecamente molto più bug-free e anche lanciarsi in tecniche che usualmente non ci avventura a seguire in C++. Mi spiego: se uno ha in C++ una struttura di 16-20 byte, 30 byte, è molto probabile che la passi per valore per evitare problemi di allocazione/deallocazione e/o stray pointers. Anche in assenza di bugs, ci sono problemi di frammentazione della memoria; e in C++, a meno di utilizzare librerie di garbage collection esplicite, questi permangono. Invece in C# è altamente probabile che uno utilizzi una classe per cui hai solo una reference, un puntatore a questo oggetto senza la preoccupazione di doverlo ri-allocare. A questo punto una chiamata di funzione costa meno perché una reference costa meno di una struttura da 20-30 bytes, spesso copiata usando una funzione della runtime. Questo rende molte volte il codice di calcolo scritto in C# più veloce di quello equivalente scritto in C++. Certo è chiaro che se uno si mette ad ottimizzare, con il C/C++ si ottengono risultati egregi ma la verità è che con i tempi di sviluppo che ci sono oggi di fatto quasi nessuno ha più il tempo di fare un lavoro così spinto. Mi è capitato molto spesso proprio per questo motivo di avere codice scritto in C# che fosse più veloce dell’equivalente in C++. Ottenere gli stessi risultati in C++ costa tempo di sviluppo. Ovviamente il C# va molto male sui cicli stretti e sugli if: se uno ha un ciclo for stretto e non può usare un iteratore come un foreach, lì ci perde parecchio in termini di prestazioni. Questo perché se uno guarda il disassemblato del codice in C# (cosa che continuo a fare) si rende conto che gli array bound check vengono implementati in una maniera che comunque interrompe spesso la coda di prefetch del processore.
S. Alla fine mettendo tutto sulla bilancia, oggi scegli il C#?”
K. Alla fine, si. Di fatto, uso il C++ solo per pezzi di codice molto specifici dove però compete coll’assembler. Molto spesso c’è una funzione C++ che dentro ha un pezzo in Assembler. Per cui, il C++ è usato solo come un comodo assemblatore. Per il resto, uso il C#. Per quanto mi riguarda, il C++ è un linguaggio in obsolescenza. Anche se debbo ad esso molto della mia carriera di programmatore, però di fatto non ci sono molti vantaggi nell’utilizzarlo. Ad esempio, per la scrittura di interfacce grafiche, se uno mira alla portabilità su altre piattaforme, l’ambiente .NET costituisce il mezzo privilegiato. Lo stesso codice prodotto sotto Windows, senza ricompilazione, gira alla perfezione sotto Linux solo con interfacce grafica leggermente diversa (la forma delle finestre,etc). L’applicazione funziona e si vede bene: questo è un grandissimo vantaggio. Diversamente, o si scrive l’interfaccia grafica due volte, o ci si affida ad emulatori che spesso però danno problemi. Oltretutto, .NET consente di utilizzare un modello di multi-threading unificato, anche cambiando sistema operativo, e questo è un altro vantaggio non di poco conto perché sia chi scrive un’interfaccia grafica, sia chi scrive un’applicazione di acquisizione dati real-time o addirittura di calcolo distribuito ha bisogno di un sistema multi-threading efficiente. Se lo si fa in C++, cambiando sistema operativo, si è costretti a riscrivere tutte le librerie. Questo costa troppo, costa bug e, per quanto mi riguarda, nell’ambiente in cui opero, la portabilità è una richiesta fondamentale. Anche se qui preferiamo lavorare sotto piattaforma Windows, di fatto il codice che noi sviluppiamo è sempre scritto per essere utilizzato sotto altre piattaforme.
Col .NET risparmiamo molto tempo. E poi oggi, col costo dei processori che è molto basso, non è difficile avere macchine con 40 core o più. Con un migliaio di euro in più si riesce a raddoppiare la potenza di calcolo mentre investendo un migliaio di euro in sviluppo (cosa che vuol dire diversi giorni di lavoro) non si raggiunge lo stesso risultato. Per sfruttare le possibilità offerte sia da cluster di calcolo che sono sempre piu facilmente disponibili che in prospettiva il cloud computing è molto più importante riuscire a scrivere codice che giri sotto queste piattaforme piuttosto che fare ottimizzazione spinta come ho fatto io stesso. Parlavamo prima del codice di acquisizione dati. Quel codice è stato scritto col manuale del processore davanti contando i cicli di clock per ogni istruzione. Quando si presentavano alternative, si eseguiva per ognuna di esse il calcolo dei cicli di clock, e alla fine si sceglieva la migliore. Oggi, se vai su un cluster di calcolo, non sai a priori su che macchina gira il tuo codice. Sarà un Intel, un AMD, o altro? Le code di prefetch Sono implementate diversamente. Ho visto sui miei benchmark delle cose anche divertenti. Gli stessi pezzi di codice che perdevano un 50% di tempo in più cambiando tipo di processore perché la logica di ottimizzazione del prefetch era diversa. Quindi una ottimizzazione di codice diventa inutile o non dà grossi vantaggi. E’ molto più importante riuscire ad utilizzare tutta la potenza di calcolo di un cluster.
S. Torniamo un attimo al C++ e ai suoi compilatori. Tu sei partito, se non sbaglio, col Borland.
K. Si. Ad un certo punto ho utilizzato un Borland 3,51..Potrei però confondermi con la numerazione del sistema operativo. Sicuramente era un 3 e qualcosa….Qualcosa come 11 floppy disk di installazione. All’epoca il compilatore Microsoft faceva cose un po’ bizzarre: ricordo qualcosa di strano su un metodo di codifica dei double. Era, se non sbaglio, il VS4, che per fortuna non ho mai usato. Dal 5 in poi ho utilizzato il Visual Studio. Abbandonai Borland perché, di fatto, si dedicarono ad altri linguaggi come il Delphi. Conservo un buon ricordo del compilatore Borland. Era piuttosto bacato ma rispetto alla media degli altri prodotti in giro era spettacolare. Aveva una sua libreria OWL (Object Windows Library) che era antesignana delle MFC Microsoft (in realtà però non sono sicuro che cronologicamente sia andata così) però di fatto la OWL era all’epoca più completa e più facile da usare della MFC. Comunque mi son divertito molto, e scrissi anche una patch. Il compilatore Borland aveva la possibilità di farti sostituire nel Librarian le librerie di run-time, per cui avevo sostituito la fscopy perché mi ero accorto di un bug sotto Windows a 16 bit. Quando avevi un array che eccedeva i 64 K , ti veniva allocata la memoria ma se la scrittura non era allineata ai 64 k, c’era un fenomeno di sovrascrittura per cui l’ultimo pezzo della scrittura veniva messo addosso ai primi byte del segmento che cominciava con lo stesso numero di selettore. Scrissi quindi in Assembler una patch dell’fscopy in maniera tale da curare questo problema.
Sempre sotto questo compilatore, scrissi un programma di grafica per funzioni matematiche che utilizzava un parser simbolico di espressioni matematiche. Questo mi è tornato utile in seguito: si tratta di un codice che ritorna spesso nella mia storia e adesso me lo tengo ben stretto. L’ho tradotto infatti in C# . In tutti i programmi di analisi dati, invece di mettere degli elementi grafici di selezione ( selezione di posizione di una certa coordinata, selezione di angoli, etc. ) offro sempre la possibilità di inserire anche un’espressione matematica in modo da avere criteri di selezione molto più flessibili. La prima realizzazione di questo parser fu in una gara di C++ con un mio amico che ne scrisse uno che batté il mio in velocità. Allora, punto sul vivo, decisi di creare un parser che compilasse a run-time; in pratica inserivi l’espressione matematica nell’interfaccia grafica e lui ti allocava un blocco di memoria al cui interno inseriva del codice in assembly che eseguiva quel calcolo utilizzando il coprocessore matematico. Sulla media dei risultati era solo il 2% più lento del compilato Borland! Diciamo che nella gara giocai sporco ma fu un’esperienza istruttiva.
S. Vorrei tornare un attimo al Visual Studio che tu hai cominciato a utilizzare dalla versione 5 in poi. Una cosa che mi ha sempre allontanato dall’utilizzo del C++ sotto Visual Studio è stato il forte impatto iniziale e la difficoltà di ambientamento alle MFC. Tu che ne pensi?
K: In realtà dipende molto dalla guida online. Ultimamente è molto migliorata, ma in passato dovevi già sapere di che cosa avevi bisogno... c’era poco tutorial.
S. Sai che adesso ci sono le versioni Express gratuite del Visual Studio e sorprendentemente la più scaricata è proprio il C++.
K. Non mi sorprende. Credo che si tratti per lo più di studenti universitari che vogliono apprendere il liinguaggio. Ovviamente uno può provare il gcc o il djgpp che è una variante del gcc ma di fatto chi riesce a fare una manutenzione della libreria di run-time come la Microsoft? Ci sono anche prodotti industriali che però ovviamente non hanno motivo di esistere per un utente che voglia apprendere il linguaggio. Il C++ è ancora molto insegnato e questo crea un effetto traino. Però sono un po’ quelle mode che poi spariscono. Se al CERN 15 anni fa dicevi di usare il C++ ti “crocifiggevano in sala mensa”: era tutto FORTRAN. Lo stesso accade oggi se dici di usare il C#. Magari tra altri 10 anni sarà invece normale.
S. Perché gcc non ti piace?
K. Anzitutto ho trovato molti casi di non uniformità allo standard. Devo anche essere stato sfortunato perché in quel periodo era molto instabile (eravamo attorno alla versione 2.93, o 2.96... ), perché ho trovato bug. Casi in cui non era possibile compilare il codice avendo l’allineamento a 1 byte ma per forza bisognava farlo a 2 byte. Tutto ciò che ti girava con allineamento a 1 byte dovevi ricompilarlo o scriverti altro codice. Il problema sorgeva perché molte volte utilizzavo miei formati di file per cui molte volte mi era comodo fare immagini di memoria direttamente da struttura a file. Invece, col gcc, ho dovuto riscrivere tutta la parte di lettura/scrittura da file che sul Visual C++ era ovvia. Non è neanche un compilatore particolarmente veloce: sia Microsoft che Intel lo battono del 30/40% in termini di velocità. Alla fine comunque è sempre una battaglia di portabilità persa: il C++ non è portabile. Non è questione di compilatore. Puoi con molta fatica attaccare una libreria compilata in gcc a una compilata in Borland ma fai molto prima a ricompilare tutto da capo su un unico compilatore.
S. Ok, direi che per oggi può bastare. Cosa ci vuoi raccontare e /o mostrare la prossima volta.
K. Attualmente ho sviluppato una certa esperienza coi database relazionali, nell’ambito dell’esperimento OPERA. Gestiamo database attualmente nell’ordine dei 10 Tera e puntiamo ai 50 - 100 Tera. Sto lavorando molto con Oracle e con i software di interfaccia al database. Magari lo vedremo nelle prossime interviste. Direi che però possiamo proprio vedere il parser simbolico. Ne ho una versione abbastanza recente in C++ che credo sia debuggata. In realtà se poi guardiamo l’implementazione .NET è molto piu elegante. Non c’è assolutamente paragone. In .NET è possibile aggiungere dinamicamente le funzioni che debbono essere “comprese” mentre in C++ è tutto più statico; e poi con .NET alla peggio puoi sempre inventarti un “delegato”; certo in C++ c’è il puntatore a funzione, ma come la mettiamo con l’allineamento delle strutture e le convenzioni di passaggio dei parametri?
S. Poi mi piacerebbe che ci raccontassi un po alla volta come gestisci i processi di acquisizione dei dati, l’interazione col database e l’analisi dei dati.
K. Va bene!
S. Ok, allora chiudiamo qui. Alla prossima!
K. Ciao!
Più Post
Pagina seguente »