Angella Andrea

[OT] – Finalmente laureato… ma è solo l’inizio !

Andrea Angella — Fri, 30 Oct 2009 22:39:05 GMT

Ciao a tutti voi ragazzi/e di UgiDotNet, è davvero molto tempo che non scrivo su questo blog anche se ho sempre letto ogni singolo post pubblicato. Nell’ultimo anno sono stato molto occupato nel sostenere gli ultimi esami universitari, nel preparare la mia tesi di laurea e nel contribuire alla nascita e crescita di DotNetToscana.

In data 8 Ottobre 2009 ho finalmente completato il mio percorso di studi con risultati davvero eccezionali: 110 e lode con percorso di eccellenza !

Il video di presentazione e tutte le foto della cerimonia e della festa sono liberamente fruibili a questo indirizzo: http://picasaweb.google.it/angella.andrea/LaureaSpecialisticaEFesta#

E’ doveroso per me lodare le eccezionali capacità tecniche del mio relatore Tommaso Cucinotta, ricercatore della Scuola Superiore Sant’Anna di Pisa. Fanstastico notare che la sua homepage è suddivisa in due sezioni, quella “professionale” e quella “hobby & tempo libero”, e che in quest’ultima c’è scritto: “Il mio hobby preferito è da sempre l'informatica e la programmazione.”. Insomma è uno di quei pochi fortunati (o da alcuni punti di vista “fulminati”) ad amare veramente l’informatica e la programmazione tanto da occupare anche il suo tempo libero. Bhe io mi sento come lui e come molti iscritti a questo blog. Abbiamo costantemente “Sete di conoscenza”…. io ne ho davvero tanta !!!

La laurea rappresenta per me solamente il punto di partenza. Adesso che ho terminato il mio percorso formativo è ora finalmente di iniziare la mia crescita professionale. L’8 Novembre 2009 partirò per Londra e farò un corso di inglese super-intensivo di 6 settimane in Regent School. Vivrò in famiglia. Ho preso l’importante decisione di cercare lavoro a Londra iniziando quindi la mia esperienza professionale all’estero o almeno voglio provarci. Ultimamente sono stato molto più presente su Facebook rispetto a UgiDotNet, chi di voi mi conosce mi aggiunga pure alla lista degli amici.

Concludo facendo le mie più sincere congratulazioni a tutti i ragazzi che hanno ricevuto per la prima volta o che sono stati confermati nuovamente MVP. Siete grandi e vi stimo tantissimo !!!

A presto

I Love HTML.it – Ho vinto la maglietta :)

Andrea Angella — Tue, 28 Jul 2009 17:29:29 GMT

HTML.it ha organizzato un gioco estivo su Facebook per promuovere il loro fantastico portale.
Si trattava di scrivere un breve testo in cui ogni utente spiegava le motivazioni per cui “ama” HTML.it.
I primi dieci che ottenevano più apprezzamenti vincevano una maglietta !!!

Sono tra i vincitori (terzo classificato)….niente di particolare, ma fa sempre piacere !

Qui la classifica definitiva dei vincitori:
http://www.facebook.com/home.php#/note.php?note_id=119827629084&ref=mf

Ciao a tutti

IV UgiAltNetConf (27 Giugno 2009) - Impressioni

Andrea Angella — Sun, 28 Jun 2009 12:33:30 GMT

Ieri ho partecipato alla quarta UgiAlt.Net Conference a Bologna. E’ stata una giornata molto intensa, e i contenuti sono stati davvero molto interessanti.

In primis la sessione su Mono tenuta da Massimiliano Mantione. E’ stato veramente interessante conoscere i principali aspetti di Mono raccontati da un profondo conoscitore degli internals del framework. La sua enorme competenza tecnica che traspare evidente dalla sua sessione mi ha colpito tantissimo. Complimenti Massimiliano !!!

In secondo luogo è stato bello partecipare all’open space su Model View ViewModel con Mauro Servienti anche se non avevo ancora avuto modo di applicare questo pattern. E’ stupefacente la profonda conoscenza tecnologica di Mauro e il suo approccio estremamente pragmatico nell’affrontare i problemi. Ho seguito anche la sua ultima sessione di “UI Composition” ma devo ammettere che per quanto mi riguarda è un tema ancora troppo avanzato per me ma ho comunque colto le problematiche affrontate.

Anche la sessione di Roberto Valenti sulla sua esperienza nel refactoring di codice legacy è stata molto istruttiva e ha evidenziato una metodologia che può funzionare basata sull’analisi di metriche del codice e sull’applicazione più o meno sistematica di principi dell’OOP e del testing.

Infine la sessione su “Come progettare l’UX” di Daniela Panfili mi ha incuriosito in quanto ha offerto una prospettiva differente nel come può essere affrontato il problema di progettare interfacce grafiche separando il più possibile il lavoro dello sviluppatore da quello del grafico. Ero un pò scettico su questo aspetto ma l’esperienza di Daniela sembra dimostrare che spesso e volentieri l’approccio che ha presentato può funzionare e portare a una maggiore soddisfazione del cliente stesso forzandolo a scontrarsi fin da subito su tutti i possibili problemi di usabilità che lei chiamava “criticità”.

Andare a questi eventi è per me molto stimolante e mi fa rendere conto di quanta strada ancora devo fare nel fantastico mondo della programmazione. Inoltre è molto bello per me conoscere e rivedere persone che hanno la mia stessa passione.

Un sentito grazie a tutti gli organizzatori e agli ottimi speaker che hanno tenuto le varie sessioni della giornata.

A presto !

Moonlight 1.0 porta Silverlight su Linux

Andrea Angella — Fri, 13 Feb 2009 10:37:51 GMT

Novell ha completato la prima versione stabile di Moonlight.

Ecco qui il link alla notizia: http://punto-informatico.it/2549927/PI/News/moonlight-10-porta-silverlight-linux.aspx

Tanti auguri e segnalazione articolo sul .NET Micro Framework

Andrea Angella — Thu, 01 Jan 2009 18:27:55 GMT

Prima di tutto a voi ragazzi e ragazze di UgiDotNet:

Tanti auguri e felice 2009 !

Approfitto dell'occasione per segnalare a tutti che ho realizzato e pubblicato un nuovo articolo per la community di DotNetToscana.
Il titolo dell'articolo è "Introduzione al .NET Micro Framework".

Di seguito elenco le sezioni di cui è composto:

Introduzione allo sviluppo su piattaforme embedded
Che cos'è e perché è stato creato il .NET Micro Framework
Versioni disponibili e caratteristiche principali
Architettura del framework e Common Language Runtime
Uno sguardo alla Base Class Library
Come iniziare a sviluppare con il .NET Micro Framework
Risorse utili per ottenere maggiori informazioni

Un saluto a tutti !

Intervista al Team Leader di JQuery

Andrea Angella — Mon, 24 Nov 2008 21:37:18 GMT

Su HTML.it è possibile trovare la traduzione in italiano dell'interessante intervista a John Resig che è il Team Leader del framework JQuery.

Può essere sicuramente interessante valutare l'acquisto del suo libro Pro Javascript Techniques e di un altro intitolato Secrets of the Javascript Ninja che sarà disponibile il prossimo anno.

Nel frattempo sono in attesa del libro JQuery in Action che sono molto curioso di leggere. Gian Maria è colpa tua :-)

[70-536] GZipStream class, DeflateStream class and Isolated Storage

Andrea Angella — Tue, 18 Nov 2008 13:07:17 GMT

Area di riferimento

- Implementing serialization and input/output functionality in a .NET Framework application (18 percent)
   - Compress or decompress stream information in a .NET Framework application and improve the security of application data by using isolated storage
      - May include but is not limited to: IsolatedStorageFile class, IsolatedStorageFileStream class;
      - DeflateStream class; GZipStream class

GZipStream and DeflateStream classes

La classi GZipStream e DeflateStream permettono di comprimere dati utilizzando il famoso algoritmo di compressione Gzip. Conviene utilizzare la classe GZipStream nel caso in cui si intenda distribuire i file in modo che questi possano essere decompressi utilizzando l'ampiamente diffuso tool gzip.

Queste classi si trovano nel namespace System.IO.Compression e il loro utilizzo è molto semplice.

    class Program
    {
        static void Main(string[] args)
        {
            File.WriteAllText("source.txt", "Il contenuto di questo file verra' compresso.");

            // File compression
            using (FileStream sourceFile = File.Open("source.txt", FileMode.Open))
            {
                using (FileStream destinationFile = File.Open("destination.dat", FileMode.Create))
                {
                    using (GZipStream comp = new GZipStream(destinationFile, CompressionMode.Compress))
                    {
                        int b;
                        while ((b = sourceFile.ReadByte()) != -1)
                        {
                            comp.WriteByte((byte)b);
                        }
                    }
                }
            }  
         
            // File decompression
            using (FileStream sourceFile = File.Open("destination.dat", FileMode.Open))
            {
                using (FileStream destinationFile = File.Open("new-source.txt", FileMode.Create))
                {
                    using (GZipStream decomp = new GZipStream(sourceFile, CompressionMode.Decompress))
                    {
                        int b;
                        while ((b = decomp.ReadByte()) != -1)
                        {
                            destinationFile.WriteByte((byte)b);
                        }
                    }
                }
            }

            Console.WriteLine(File.ReadAllText("new-source.txt"));
            Console.ReadKey();
        }
    }

Isolated Storage

L'Isolated Storage è un repository all'interno del quale è possibile leggere e scrivere dati in maniera sicura indipendentemente dai privilegi di cui disponde il codice.

La prima cosa da fare quando si lavora con l'isolated storage è scegliere l'ambito in cui saranno memorizzati i dati:

Assembly/Machine : Si utilizza questo ambito per persistere dati a livello di applicazione.
Assembly/User : Si utilizza questo ambito per persistere dati a livello di utente. Ogni utente della macchina avrà le sue impostazioni specifiche.
...

L'utilizzo dell'Isolated Storage ruota intorno alle classi IsolatedStorageFile e IsolatedStorageFileStream. E' inoltre possibile utilizzare l'attributo IsolatedStorageFilePermission per specificare il permesso di accedere all'Isolated Storage e impostare altri parametri come ad esempio la quota massima di spazio da associare a ciascun utente.

    [IsolatedStorageFilePermission(SecurityAction.Demand, UserQuota=256)]
    class Program
    {
        static void Main(string[] args)
        {
            // Assembly/Machine Scope - Writing data

            IsolatedStorageFile applicationStorage = IsolatedStorageFile.GetMachineStoreForAssembly();

            IsolatedStorageFileStream applicationStream = 
                new IsolatedStorageFileStream("application-settings.dat", FileMode.Create, applicationStorage);

            using (StreamWriter writer = new StreamWriter(applicationStream))
            {
                writer.Write("Informazioni a livello applicazione");
            }

            // User/Machine Scope - Writing data

            IsolatedStorageFile userStorage = IsolatedStorageFile.GetUserStoreForAssembly();

            IsolatedStorageFileStream userStream =
                new IsolatedStorageFileStream("user-settings.dat", FileMode.Create, userStorage);

            using (StreamWriter writer = new StreamWriter(userStream))
            {
                writer.Write("Informazioni a livello utente in user-settings.dat");
            }

            userStorage.CreateDirectory("folder");

            userStream = new IsolatedStorageFileStream(@"folder\user-settings.dat", FileMode.Create, userStorage);

            using (StreamWriter writer = new StreamWriter(userStream))
            {
                writer.Write("Informazioni a livello utente in folder\\user-settings.dat");
            }

            // Reading data

            Console.WriteLine("Directories :");
            foreach (string directory in userStorage.GetDirectoryNames("*"))
            {
                Console.WriteLine(directory);
            }

            Console.WriteLine("Files *.dat :");
            foreach (string file in userStorage.GetFileNames("*.dat"))
            {
                Console.WriteLine(file);
            }

            Console.ReadKey();
        }
    }

[70-536] - File System classes and Streams

Andrea Angella — Tue, 18 Nov 2008 12:51:37 GMT

Area di riferimento

- Implementing serialization and input/output functionality in a .NET Framework application (18 percent)
   - Access files and folders by using the File System classes
      - May include but is not limited to: File class and FileInfo class; Directory class and DirectoryInfo class;
      - DriveInfo class and DriveType enumeration; FileSystemInfo class and FileSystemWatcher class; Path class;
      - ErrorEventArgs class and ErrorEventHandler delegate; RenamedEventArgs class and RenamedEventHandler delegate
   - Manage byte streams by using Stream classes
      - May include but is not limited to: FileStream class; Stream class; MemoryStream; BufferedStream class
   - Manage .NET Framework application data by using Reader and Writer classes
      - May include but is not limited to: StringReader class and StringWriter class; TextReader class and TextWriter class;
      - StreamReader class and Stream Writer class; BinaryReader class and BinaryWriter class

File System classes

Il framework .NET offre numerose classi che permettono l'accesso al file system.

La classe DriveInfo permette di ottenere informazioni relative ai drive presenti sulla macchina. La classe File permette di effettuare alcune tipiche operazioni sui file come la copia, la creazione e la cancellazione. Le classi FileInfo e DirectoryInfo derivano da FileSystemInfo e consentono di accedere a diverse informazioni relative a file e directory. Utilizzando queste classi inoltre è estremamente semplice navigare attraverso il file system ottenendo l'elenco dei file presenti all'interno di una directory e l'elenco di directory presenti all'interno di un'altra directory. La classe Path fornisce un valido supporto per estrapolare informazioni relative ad un path e soprattutto offre una comoda funzione per combinare due path fra loro.

Grazie all'interessantissima classe FileSystemWatcher è inoltre possibile monitorare in tempo reale le modifiche che vengono compiute all'interno di una particolare cartella semplicemente gestendo opportuni eventi.

Di seguito riporto un pò di codice che utilizza tutte queste classi. Il loro utilizzo è molto intuitivo per questo non ritengo necessaria alcuna ulteriore spiegazione.

  1     class Program
  2     {
  3         static void Main(string[] args)
  4         {
  5             Console.WriteLine("Drive\n");
  6 
  7             DriveInfo driveInfo = new DriveInfo("C");
  8             Console.WriteLine("Name: {0}", driveInfo.Name);
  9             Console.WriteLine("TotalSize: {0} bytes", driveInfo.TotalSize);
 10             Console.WriteLine("TotalFreeSpace: {0} bytes", driveInfo.TotalFreeSpace);
 11             Console.WriteLine("AvailableFreeSpace: {0} bytes", driveInfo.AvailableFreeSpace);
 12             Console.WriteLine("DriveFormat: {0}", driveInfo.DriveFormat);
 13             Console.WriteLine("DriveType: {0}", driveInfo.DriveType);
 14             Console.WriteLine("VolumeLabel: {0}", driveInfo.VolumeLabel);
 15 
 16             Console.WriteLine("\nFile:\n");
 17 
 18             File.AppendAllText("file1.txt", "Ciao a tutti da Andrea", Encoding.ASCII);
 19             File.Copy("file1.txt", "file2.txt", true);
 20 
 21             FileInfo file2Info = new FileInfo("file2.txt");
 22             Console.WriteLine("CreationTime: {0}", file2Info.CreationTime);
 23             Console.WriteLine("LastWriteTime: {0}", file2Info.LastWriteTime);
 24             Console.WriteLine("DirectoryName: {0}", file2Info.DirectoryName);
 25             Console.WriteLine("Exists: {0}", file2Info.Exists);
 26             Console.WriteLine("Extension: {0}", file2Info.Extension);
 27             Console.WriteLine("FullName: {0}", file2Info.FullName);
 28             Console.WriteLine("Name: {0}", file2Info.Name);
 29             Console.WriteLine("IsReadOnly: {0}", file2Info.IsReadOnly);
 30             Console.WriteLine("Length: {0}", file2Info.Length);
 31 
 32             Console.WriteLine("\nDirectory:\n");
 33 
 34             DirectoryInfo dir2Info = file2Info.Directory;
 35             Console.WriteLine("CreationTime: {0}", dir2Info.CreationTime);
 36             Console.WriteLine("FullTime: {0}", dir2Info.FullName);
 37             Console.WriteLine("Exists: {0}", dir2Info.Exists);
 38             Console.WriteLine("LastAccessTime: {0}", dir2Info.LastAccessTime);
 39             Console.WriteLine("LastWriteTime: {0}", dir2Info.LastWriteTime);
 40 
 41             dir2Info.CreateSubdirectory("folder1");
 42             dir2Info.CreateSubdirectory("folder2");
 43             dir2Info.CreateSubdirectory("folder3");
 44 
 45             Console.WriteLine("Files in folder: ");
 46             foreach (FileInfo fileInfo in dir2Info.GetFiles())
 47             {
 48                 Console.WriteLine("\t{0}", file2Info.Name);
 49             }
 50 
 51             Console.WriteLine("Directory in folder: ");
 52             foreach (DirectoryInfo dirInfo in dir2Info.GetDirectories())
 53             {
 54                 Console.WriteLine("\t{0}", dirInfo.Name);
 55             }
 56 
 57             if (Directory.Exists("folder1"))
 58             {
 59                 Directory.Delete("folder1");
 60             }
 61             Directory.Delete("folder2");
 62             new DirectoryInfo("folder3").Delete();
 63             file2Info.Delete();
 64 
 65             Console.WriteLine("\nPath: c:\\prova\\file.txt \n");
 66             Console.WriteLine("GetDirectoryName: {0}", Path.GetDirectoryName(@"c:\prova\file.txt"));
 67             Console.WriteLine("GetExtension: {0}", Path.GetExtension(@"c:\prova\file.txt"));
 68             Console.WriteLine("GetFileName: {0}", Path.GetFileName(@"c:\prova\file.txt"));
 69             Console.WriteLine("GetFileNameWithoutExtension: {0}", Path.GetFileNameWithoutExtension(@"c:\prova\file.txt"));
 70             Console.WriteLine("GetFullPath: {0}", Path.GetFullPath(@"c:\prova\file.txt"));
 71             Console.WriteLine("GetPathRoot: {0}", Path.GetPathRoot(@"c:\prova\file.txt"));
 72             Console.WriteLine("GetRandomFileName: {0}", Path.GetRandomFileName());
 73             Console.WriteLine("GetTempPath: {0}", Path.GetTempPath());
 74             Console.WriteLine("GetTempFileName: {0}", Path.GetTempFileName());
 75        
 76             Console.WriteLine("Combine: {0}", Path.Combine("c:\\prova1", "prova2\\file.txt"));
 77             
 78             Console.WriteLine("\nFileSystemWatcher: \n");
 79 
 80             Directory.CreateDirectory("folder");
 81             FileSystemWatcher fsWatcher = new FileSystemWatcher("folder");
 82             fsWatcher.Created += new FileSystemEventHandler(fsWatcher_Created);
 83             fsWatcher.Deleted += new FileSystemEventHandler(fsWatcher_Deleted);
 84             fsWatcher.Changed += new FileSystemEventHandler(fsWatcher_Changed);
 85             fsWatcher.Renamed += new RenamedEventHandler(fsWatcher_Renamed);
 86             fsWatcher.Error += new ErrorEventHandler(fsWatcher_Error);
 87 
 88             fsWatcher.EnableRaisingEvents = true;
 89 
 90             Console.ReadKey();
 91         }
 92 
 93         static void fsWatcher_Error(object sender, ErrorEventArgs e)
 94         {
 95             Console.WriteLine("FileSystemWatcher Error\n");
 96         }
 97 
 98         static void fsWatcher_Changed(object sender, FileSystemEventArgs e)
 99         {
100             Console.WriteLine("ChangeType: {0}", e.ChangeType);
101             Console.WriteLine("FullPath: {0}", e.FullPath);
102             Console.WriteLine("Name: {0}\n", e.Name);
103         }
104 
105         static void fsWatcher_Renamed(object sender, RenamedEventArgs e)
106         {
107             Console.WriteLine("ChangeType: {0}", e.ChangeType);
108             Console.WriteLine("FullPath: {0}", e.FullPath);
109             Console.WriteLine("Name: {0}", e.Name);
110             Console.WriteLine("OldFullPath: {0}", e.OldFullPath);
111             Console.WriteLine("OldName: {0}\n", e.OldName);
112         }
113 
114         static void fsWatcher_Deleted(object sender, FileSystemEventArgs e)
115         {
116             Console.WriteLine("ChangeType: {0}", e.ChangeType);
117             Console.WriteLine("FullPath: {0}", e.FullPath);
118             Console.WriteLine("Name: {0}\n", e.Name);
119         }
120 
121         static void fsWatcher_Created(object sender, FileSystemEventArgs e)
122         {
123             Console.WriteLine("ChangeType: {0}", e.ChangeType);
124             Console.WriteLine("FullPath: {0}", e.FullPath);
125             Console.WriteLine("Name: {0}\n", e.Name);
126         }
127     }

Streams

Gli stream realizzano un meccanismo unificato per gestire l'accesso sequenziale e random ai dati. La classe astratta Stream fornisce l'interfaccia di base e l'implementazione per tutti gli strem all'interno del Framework. Quando si apre un file viene restituito un oggetto di tipo FileStream che offre una interfaccia di basso livello per l'accesso al file. Le classi StreamReader e StreamWriter facilitano la lettura e la scrittura di file di testo. Le classi BinaryReader e BinaryWriter invece permettono la lettura e la scrittura di dati binari in modo più semplice del dover lavorare direttamente su vettori di byte.

Quando si lavora con piccoli file di testo è possibile utilizzare le funzioni File.WriteAllText e File.ReadAllText rispettivamente per scrivere un file di testo a partire da una stringa e per ottenere il contenuto di un file di testo all'interno di una stringa.

La classe MemoryStream fornisce le funzionalità per creare stream in memoria. Le classi StringReader e StringWriter invece svolgono le stesse funzionalità delle classi StreamReader e StreamWriter solo che la sorgente dati associata è una stringa al contrario di un file ( le classi astratte da cui derivano sono TextReader e TextWriter che implementano le funzionalità di base per la lettura e scrittura di testo).

Ecco un pò di codice dimostrativo:

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             Console.WriteLine("*** Text Streams: ***\n");
 6 
 7             FileStream fs = File.Open("file.txt", FileMode.Create);
 8 
 9             byte[] bytesTitolo = new ASCIIEncoding().GetBytes("Titolo del file\r\n\r\n");
10             fs.Write(bytesTitolo, 0, bytesTitolo.Length);
11 
12             using (StreamWriter sw = new StreamWriter(fs))
13             {
14                 sw.WriteLine("Ciao a tutti");
15                 sw.WriteLine("il mio nome Ã¨ Andrea");
16             }
17 
18             using (StreamReader sr = File.OpenText("file.txt"))
19             {
20                 while (!sr.EndOfStream)
21                 {
22                     Console.WriteLine(sr.ReadLine());
23                 }
24             }
25 
26             Console.WriteLine();
27 
28             File.WriteAllText("file2.txt", "Prima riga del file2\r\nSeconda riga del file2");
29             Console.WriteLine(File.ReadAllText("file2.txt"));
30 
31             Console.WriteLine("\n*** Binary Streams: ***\n");
32 
33             fs = File.Open("file3.dat", FileMode.Create);
34             using (BinaryWriter bw = new BinaryWriter(fs))
35             {
36                 bw.Write('A');
37                 bw.Write(true);
38                 bw.Write(12.45);
39                 bw.Write("Ciao");
40             }
41             fs = File.Open("file3.dat", FileMode.Open);
42             using (BinaryReader br = new BinaryReader(fs))
43             {
44                 Console.WriteLine(br.ReadChar());
45                 Console.WriteLine(br.ReadBoolean());
46                 Console.WriteLine(br.ReadDouble());
47                 Console.WriteLine(br.ReadString());
48             }
49 
50             Console.WriteLine("\n*** Memory Streams: ***\n");
51 
52             MemoryStream ms = new MemoryStream();
53             using (StreamWriter sw = new StreamWriter(ms))
54             {
55                 sw.WriteLine("Scrivo su uno stream in memoria.");
56                 sw.Flush();
57 
58                 using (fs = File.Open("file.txt", FileMode.Append))
59                 {
60                     ms.WriteTo(fs);
61                 }
62             }
63 
64             Console.ReadKey();
65         }
66     }

Infine è importante citare la classe BufferedStream che permette di migliorare le performance implementando un meccanismo di lettura e scrittura bufferizzato.

DotNetToscana: il principio.

Andrea Angella — Sat, 08 Nov 2008 14:38:48 GMT

Io, Andrea Angella, sono diventato un membro della community UgiDotNet il giorno 9 Agosto 2007 con il post Finalmente il mio blog tecnico. Circa un mese dopo alle ore 10:33 del giorno 11 Settembre 2007 (gli attentati fortunatamente non centrano niente) arriva nella mia casella di posta elettronica una mail da parte di Matteo Baglini.

Riporto il testo integrale di questa "storica" mail:

"Ciao,
girovagando per il tuo blog ho letto che studi a Pisa quindi non credo che abiti fuori Toscana, spero di non essere invadente ed antipatico, però ti volevo chiedere se hai letto della cena che sto organizzando a Livorno http://blogs.ugidotnet.org/bmatte/archive/2007/09/06/cacciuccata-a-livorno-il-29-settembre.aspx. Ti va di venire? Se hai già letto l'annuncio e non sei interessato ti va di spiegarmi il perchè? Ti chiedo queste cose perchè ho visto che sono molto pochi i Toscani che hanno risposto all'appello e volevo capire il motivo, in modo da migliorare per un eventuale cena futura e perchè magari anche per questa. Ti chiedo ancora scusa per il disturbo e spero non essere stato scortese.

Ciao Matteo."

Ero molto felice di aver ricevuto quella mail ed ho accettato ben volentieri l'invito alla cena. Da quell'istante la mia presenza in UgiDotNet si è concretizzata, sapevo che quello sarebbe stato solo l'inizio di una serie di incontri che mi avrebbero permesso di conoscere personalmente persone eccezionali che condividono la mia forte passione per l'informatica e con le quali avrei potuto passare piacevoli momenti insieme per divertirsi, discutere e condividere esperienze. E così è stato...

La sera del 29 Settembre 2007 ho quindi partecipato alla prima cena con membri di UgiDotNet. Eravamo solamente in 4 (Io, Matteo Baglini, Igor Damiani e Omar Damiani) ma la serata è stata davvero molto piacevole. Verso mezzanotte i due fratelli Damiani (che ringrazio ancora per il forte spirito di community che mi hanno dimostrato) sono tornati a casa. Io avevo il treno verso le ore 3 quindi Matteo ha pensato di portarmi in un pub per fare quattro chiacchere. Dopo avermi presentato la ragazza (al contrario di me lui è felicemente fidanzato) e alcune sue amiche, non abbiamo resistito alla tentazione di tornare a parlare di .NET :-)

E' proprio lì che per la primissima volta abbiamo parlato della possibilità di costruire insieme una nuova community come punto di incontro di studenti e professionisti Microsoft presenti nella regione Toscana. I problemi erano tanti, in primis che eravamo pochi (la cena purtroppo era stata una triste conferma). Matteo pensava in grande, voleva fare le cose con i giusti tempi affinchè tutto non si rivelasse un fallimento, per questo prima di tutto voleva confrontarsi con altri ragazzi delle community regionali. Vedevo in lui una forte motivazione, un'estrema passione per il suo lavoro e soprattutto un incredibile spirito di community.

Il giorno 16 Ottobre 2008, ad un anno da quella data, ai Microsoft Days 2008 è stata ufficialmente presentata a Firenze la community DotNetToscana.

DotNetToscana è per sua volontà una associazione no-profit, dove non esistono ruoli ufficiali ma tutto evolve grazie alla passione di ciascun membro. Nonostante questo per me, Matteo Baglini è il Leader naturale del gruppo, colui che ha creduto e reso possibile tutto questo. Oggi è il compleanno di Matteo e questo post è il mio regalo per lui.

Il più grande augurio è che DotNetToscana possa crescere per diventare un punto di riferimento e sicuramente tutti i suoi attuali membri si impegneranno per questo.

Tanti auguri di Buon Compleanno Matteo !
Tanti auguri di Buon Inizio DotNetToscana !

Andrea

"Informatica Industriale" superato alla grande :-)

Andrea Angella — Thu, 06 Nov 2008 20:07:30 GMT

Questa mattina io e il mio collega Vincenzo abbiamo sostenuto l'esame di Informatica Industriale conseguendo entrambi una votazione pari a 30 e Lode !

L'esame consisteva (in parte) nella realizzazione del progetto di un semplice Sistema Embedded in modo da familiarizzare con la programmazione di microcontrollori. Abbiamo utilizzato il microcontrollore ADuC836 con un core a 8 bit (8052) e realizzato il software in linguaggio C.

Il risultato si chiama Speedy Finger ed è la realizzazione in hardware del semplice gioco del dito più veloce.

Di seguito il logo creato (ovviamente non realizzato da me che di grafica sono molto carente):

Per l'occasione (come richiesto dai docenti) abbiamo realizzato un video di presentazione disponibile su YouTube anche in alta risoluzione:

Oggi termina una lunga serie di progetti universitari che ho realizzato insieme a Vincenzo, collega ma soprattuto grande e sincero amico che ringrazio particolarmente per aver reso molto più piacevole (se non divertente) questo ultimo anno accademico.

Adesso personalmente cercherò di sostenere al più presto l'ultimo esame rimastomi per poi iniziare l'avventura della Tesi.