Articles

Java -> Scala: Inner Annotations

2011-11-03T03:20:00.000-07:00

Da poco mi sono convinto che è giunto il momento di provare a utilizzare Scala non più per gioco ma cercando di creare qualcosa di concreto in ambiente Enterprise.

L'utilizzo di Scala in ambiente Enterprise non può non scontrarsi con gli RDBMS.

La questione che mi sono trovato ad affrontare è quello di volere esprimere attraverso le annotazioni in scala una relazione ManyToMany attraverso una tabella di join.

Di seguito illustro la soluzione in Java e poi quella in Scala:

Java

@ManyToMany(targetEntity = Product)
@JoinTable(name = "ORDERS_PRODUCTS",
           joinColumns = {@JoinColumn(name="ORDER_ID", 
                                  referencedColumnName ="ORDER_ID")},
           inverseJoinColumns = {@JoinColumn(name="PRODUCT_ID", 
                                  referencedColumnName = "PRODUCT_ID")}
List<Product> products = null;

Scala

@ManyToMany(targetEntity = classOf[Product])
@JoinTable(name = "ORDERS_PRODUCTS",
           joinColumns = Array(new JoinColumn(name="ORDER_ID", 
                              referencedColumnName ="ORDER_ID")),
           inverseJoinColumns = Array(new JoinColumn(name="PRODUCT_ID", 
                                 referencedColumnName = "PRODUCT_ID")))
@BeanProperty
var products:List[Product] = null

Ricordo che l'estratto del codice scritto in Scala compila soltanto se viene usato un compilatore Scala la cui versionesia maggiore uguale alla 2.8.0 a causa di un bug presente nelle versioni precedenti.

Let's put a string date to a Zulu Date

2010-09-30T00:34:00.000-07:00

public class USPacificZuluDate

{

public static void main(String[] args) throws Exception

{

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.S'Z");

sdf.setTimeZone(TimeZone.getTimeZone("UTC"));

System.out.println(sdf.format(currentDate));

Date parsedDate = sdf.parse("1970-01-01T00:00:00.0UTC");

System.out.println(sdf.format(parsedDate));

}

Alla scoperta del file system di Linux

2008-03-18T01:38:00.000-07:00

In quest’articolo andremo alla scoperta del filesystem di un sistema operativo Linux dandone una prima visione generale che potrà risultare utile come primo punto di inizio. Molte persone che si avvicinano a questo sistema operativo, si sentono confusi alla vista del suo filesystem, principalmente perché esso si presenta come una non semplice gerarchia di file e directory.

Iniziamo dicendo che in Linux esiste una singola struttura gerarchica delle directory. Ogni cosa inizia dalla directory root, rappresentata da ‘/‘; e si ramifica in una struttura dati ad albero formando directory e sotto directory. Mentre nei sistemi operativi DOS/Windows possiamo avere varie partizioni
all’interno delle quali sono presenti le directory, in Linux tutte le partizioni sono presenti all’interno della directory root eseguendo il ‘mount‘ sotto specifiche directory. Volendo paragonare, la root directory di Linux sarebbe la partizione C: di Windows.

A loro volta, in Windows le varie partizioni vengono identificate durante la fase di boot (fatta eccezione per i dispositivi plug&play). Ma in Linux, se non viene eseguito il mount di una partizione o di un dispositivo, il sistema non conosce l’esistenza di quella partizione o dispositivo. A prima vista questo potrebbe sembrare il modo più semplice per accedere a una partizione o a un dispositivo, ma nonostante ciò questo fornisce in compenso un’alta flessibilità e potenza.

Questo tipo di strutturazione del filesystem, offre molti vantaggi se paragonato con l’approccio utilizzato dai sistemi Windows. Prendiamo l’esempio della directory /usr. Questa contiene molti programmi eseguibili all’interno del sistema. Avendo a disposizione il filesystem di Linux possiamo scegliere di smontarla e rimontarla su un’altra partizione, o ancora su un’altra partizione di un’altra macchina sulla stessa rete. Il sistema sottostante non conoscerà la differenza poiché /usr appare come essere una directory che è parte della struttura delle directory locali. Provate a muovere la directory c:/windows/system32 su un’altra partizione o dispositivo e vedrete cosa accadrà.

* / - è chiamata root del filesystem. E’ un ramo dell’albero del filesystem e il punto di inizio del filesystem stesso. Ogni altra directory o file presente nel sistema e subordinata alla ‘/’. Dal terminale digitando cd / veniamo diretti sulla root del filesystem.

* /root - è la directory home dell’utente root. Questa solitamente conterrà file di log e script usati dall’amministratore del sistema.

* /bin - è la directory dove sono memorizzati i principali file binari sia per l’amministratore che per gli utenti comuni. Esempi sono i programmi “ls”, “cat” e “mv” oltre alle shell come bash, ksh, csh.

* /sbin - è la directory dove sono memorizzati i principali file binari usati dall’amministratore del sistema e dal sistema stesso.

* /dev - questa invece è una directory molto interessante. Essa sottolinea una importante caratteristica del filesystem di Linux. Ogni cosa in Linux è un file o una directory. In questa directory troviamo le varie partizioni montate sul primo master drive del sistema. Ad esempio /dev/cdrom e /dev/fd0 rappresentano rispettivamente il lettore CDROM e il lettore floppy mentre /dev/dsp rappresenta gli speaker del computer. Ogni cosa scritta su questo file verrà automaticamente ridiretta verso i tuoi speaker. Provate dal terminale il seguente comando: cat /etc/fstab > /dev/dsp; sentirete il suono del file fstab.

* /lib - è la directory dove vengono memorizzate le librerie condivise che occorrono alle applicazioni presenti nelle directory /bin e /sbin.

* /boot - è il punto in cui il boot loader cerca per caricare il kernel.

* /mnt - questa directory rappresenta un generico mount point all’interno della quale è consigliabile montare i nostri fylesystem e i nostri dispositivi esterni.

* /etc - è la directory dove trovano luogo molti file di configurazione del sistema. Notiamo che la directory /etc/rc.d contiene gli script per l’avvio del sistema stesso.

* /var - questa directory contiene i dati di spooling quali mail e l’output del deamon della stampante. Nella directory /var/log sono invece contenuti i file di log del sistema.

* /tmp - in questa directory sono contenuti tutti quei file che debbono essere utilizzati temporaneamente. Ad esempio, dove si trovano i file scaricati se non altrimenti indicato.

* /proc - questa directory è in realtà uno pseudo filesystem che risiede nella memoria virtuale mantenendo lo stato di tutti quei dati, interni al sistema, altamente dinamici. La maggior parte delle informazioni presenti in /proc sono consistenti con lo stato corrente del sistema operativo correntemente in esecuzione.

* /opt - questa directory dovrebbe contenere tutto il software e i pacchetti aggiuntivi che non fanno parte dell’installazione di default. In realtà, questa directory non viene usata molto spesso benché faccia parte della struttura standard di una installazione UNIX.

* /home - in questa directory sono presenti, come sotto directory, le directory di tutti quegli utenti che hanno un account sul sistema.

* /usr - questa ha come sotto directory “/usr/bin”, “/usr/sbin” e “/usr/lib” che ha lo stesso scopo delle directory “/bin”, “/sbin” e “/lib”, ma che sono necessari durante la fase di boot del sistema. Molti file binari non essenziali all’utente o al sistema trovano luogo in questa directory. La directory /usr contiene anche la maggior parte della documentazione dei binari e delle librerie installate nel sistema.

di Giuseppe Lo Brutto - TuxJournal.net

Mozilla Premia i Migliori plug-in per Firefox

2008-02-25T01:21:00.000-08:00

Mozilla ha reso noto i vincitori della competizione Extension Firefox 2 per le migliori estensioni, sviluppate da terzi, per il browser open source Firefox.
Il primo premio se lo è aggiudicato lo sviluppatore Tony Farndon, UK; creatore della Minimap Sidebar Extension. Il suddetto plug-in permette agli utenti di visusualizzare le mappe di Google, Yahoo e Live Local in una barra laterale indipendente dalla finestra principale del browser Firefox.
Il secondo premio è invece stato vinto da uno sviluppatore Italiano Massimilino Mirra per SamePlace. Il plug-in permette a Firefox di fungere da client per l’instant messaging per sei servizi differenti; incluso AIM, Yahoo Messenger e ICQ.
Il terzo premio è invece andato a uno sviluppatore degli Stati Uniti d’America Jay Meattle per il plug-in Shareholic. Questo plug-in consente agli utenti di sottomettere pagine web verso Digg, Del.icio.us, MySpace e Facebook; direttamente dalla finestra del browser Firefox.
A ogni vincitore verrà dato uno speciale kit di sviluppo, Ultimate Firefox Developer, il quale include un Macbook Pro nuovo con VMWare Fussion installato e un vioggio gratis al Mozilla Developer Day ovunque nel mondo.
Mozilla ha anche premiato i dodici plug-in più promettenti ai quali invece è stato assegnato una speciale borsa Firefox messenger e gajets, insieme a un certificato del valore di $200 spendibile per libri della casa editrice O’Reilly.

Il mondo terminerà il 19 Gennaio 2038

2008-02-19T00:03:00.000-08:00

Come molti di noi ricordano, l'ingresso dell'anno 2000 portò con sé la paura in tutto il mondo che i computer presenti all'interno delle industrie e dei vari Governi avrebbero smesso di funzionare in modo appropriato a causa del calcolo della data, bug noto a tutti con il nome di Millenium Bug. Questo avrebbe dovuto avvenire tra il 31 Dicembre 1999 e l'1 Gennaio 2000.

Mentre oggi possiamo ben affermare che in quel caso non ci sia stata una reale manifestazione del bug che abbia portato in crash i sistemi in quel momento in funzione, questo non potrebbe essere il caso per il bug Y2K38.
Anche se questo bug avrà effetto sui soli sistemi operativi Unix e derivati, se fosse vero, sarà la causa di una massiva sventura che si abbatterà sul mondo dei computer e del mondo reale allo stesso tempo.

In poche parole, il problema che si presenterà nel 2038 consiste nel fatto che i sistemi operativi Unix e derivati rappresentano internamente il tempo come il numero di secondi trascorsi dalla data 1 Gennaio 1970 alle ore 00:00:00. Su molti sistemi a 32-bit, il tipo di dato utilizzato per accumulare i secondi trascorsi a partire da quella data è il time_t che è un intero a 32-bit con segno.

Facendo un calcolo, l'ultima data che si può rappresentare con questo formato, seguendo lo standard POSIX, sarà il Giovedì 19 Gennaio 2038 alle ore 03:14:07 UTC. Al di là di questo precisto momento il contatore subirà un overflow che porterà a una rappresentazione interna del numero stesso come numero negativo.
Da qui i problemi, il sistema interpreterà questo numero non come una data che indica il 2038 ma piuttosto il 1901. Proviamo a immaginare cosa può accadere se applicazioni del monto finanziario, nucleare, elettrico e dello stesso internet dovessero subire questo problema.

Ma sarà davvero così? Il trascorre del tempo sarà causa di panico? Non del tutto. In primo luogo, l'anno 2038 si presenterà in un momento molto lontano da noi e molte cose potranno cambiare in tutto questo tempo a venire. In secondo luogo, teniamo ben in mente che solo i sistemi a 32-bit sono soggetti a questo problema e che i sistemi a 64-bit stanno piano piano facendo il loro ingresso anche sulle macchine di uso domestico, oltre che nel mondo del lavoro. Inoltre, i sistemi a 64-bit presentano un arrotondamento della data che avverrà tra 290 bilioni di anni; il ché dovrebbe essere sufficiente per rassicurare tutti quanti noi.

10 anni: da Netscape a Firefox

2008-01-31T07:39:00.000-08:00

Sono già trascorsi dieci anni da quando Netscape annunciava il rilascio al pubblico del codice sorgente del suo prodotto simbolo, rendendolo di fatto un prodotto Open Source; era Netscape Communicator 5.

Questa decisione fu presa da Netscape nel momento in cui Mozilla era il web browser che dominava la scena. Nello stesso periodo il prodotto della Microsoft, Internet Explorer (IE), stava guadagnando, inesorabilmente, quote di mercato. Ciò grazie al fatto che in quel periodo per avere Mozilla occorreva pagare una quota di 30$, mentre IE era all’inizio liberamente scaricabile come prodotto stand-alone, per poi essere fornito insieme al sistema operativo Windows 95 prima e Windows 98 poi.

In una situazione di mercato che per Netscape diventava sempre più scivolosa e incerta, Netscape prese la decisione di focalizzare i propri sforzi verso i prodotti di fascia Enterprise donando all’Open Source il proprio browser. Questo ha avuto ripercussioni per il mondo degli sviluppatori Open Source consentendo loro di lavorare, volontariamete, sul prodotto.

Riassumendo, nel tempo Mozilla diventerà il nome del progetto Open Source, la socità AOL acquisirà Netscape e IE raggiungerà il 90% dell’intero mercato, dando origine a quello che poi sarebbe stato il peggior periodo nella storia dei web browser. Nel 2002, Mozilla rilascerà poi la sua prima versione, accompagnata dal mantra: noi siamo costruttori di piattaforme, siamo dalla parte degli sviluppatori, lasciamo lo sviluppo di prodotti ad altri.

Successivamente subentrò Phoenix che partendo dall’intera suite di Mozilla ne realizzò un prodotto di consumo. Prima Phoenix e poi Firefox, che diventerà un prodotto di successo nel 2004, dimostrando che l’approccio orientato verso gli utenti è quello vincente al fine di raggiungere gli obiettivi prefissati da Mozilla.

Dopo dieci anni, tra un altalenarsi di tempi duri e buoni, di frustrazioni e soddisfazioni, il successo di Mozilla è un qualcosa che noi, cittadini interconnessi dalla rete delle reti, possiamo tranquillamente celebrare con il resto del mondo.

di Giuseppe Lo Brutto - TuxJournal.net

Il Mondo del Software Secondo me

2008-01-28T14:33:00.000-08:00

Da un pò di tempo ho iniziato a interessarmi di progetti sofware cercando di raccogliere informazioni circa le esperienze di vari Project Manager che nel tempo sono stati responsabili dell’esecuzione e della messa in opera di vari progetti software. In questo articolo ho cercato di sintetizzare eventi e riflessioni che più di frequente determinano il successo o il fallimento di un progetto software a fronte di varie esperienze maturate sul campo. Ritengo che questo possa essere utile quando affrontiamo l’attuale mondo dello sviluppo software.

Ormai sempre più spesso, noi gente del settore software, proveniamo da un mondo che ci ha fornito un apprendimento strutturato, qualcosa che in alcuni casi chiamiamo scienza e in altri ingegneria. Durante il nostro processo di apprendimento ci può sembrare che giunti nel mondo esterno per lavorare possiamo applicare gli stessi concetti e eseguire le stesse attività; ma molto più importante, ci aspettiamo un alto livello di successo, in modo simile all’esperienza da noi maturata alla fine di progetti e compiti che ci erano stati assegnati durante gli anni accademici. Ma purtroppo, il mondo non si comporta in questo modo.

Le statistiche dicono ben altro: si presume che il 50/80% dei progetti software fallisce. Questo rende il mondo dello sviluppo software alquanto inaffidabile. Un software cattivo di solito irrita le persone, ma un cattivo ingegnere può uccidere; ne sono testimonianza alcuni tra i più noti “software flop”.

Una metrica, per certi versi, più affascinante è la seguente: il 5% dei programmatori sono 20 volte più produttivi del restante 95%. Se questa fosse uan tesi comprovata, potremmo risolvere il problema su come far raggiungere a tutti quanti lo stesso livello.

Lasciatemi dire che questa regola segue la solita regola dell’80-20. In poche parole, l’80% dei programmatori non leggono libri, non vanno alle conferenze, non continuano a studiare, non fanno niente eccetto quello che hanno imparato all’università. Il restante 20% lotta giorno dopo giorno con la sua professione, leggono, provano a imparare nuove cose, ascoltano conferenze su internet (podcast) e qualche volta vanno alle conferenze. L’80% di questo 20% non riscuotono un gran successo. Il restante 20% di questo 20% (diciamo circa il 5% dell’intero) sono i 20 volte più produttivi.

Adesso il punto è: come facciamo a entrare a far parte di questo prodigioso 5%?

Le persone che fanno parte di questo 5% lottano per raggiungere quelle performance e continuano a lottare per rimanerci. E’ il processo del continuo apprendimento che fa la differenza. Leggono molto, sono sempre pronti a affrontare un nuovo concetto se sembra degno di attenzione e molto del loro tempo viene speso nell’essere produttivi e nel risolvere problemi. Essere capaci di analizzare e capire una situazione o scoprire il punto cardine di un problema per loro è essenziale.

Occore quindi innescare un processo di continuo apprendimento; ma non è così semplice. E’ enormemente importante impare di più sulla programmazione, ma non possiamo solo imparare di più sulla programmazione. Per esempio, giusto nel mondo della scrittura del codice esistono due importanti punti:

Il codice viene letto più di quanto venga scritto. Se le persone non potranno leggere il tuo codice, allo stesso modo non potranno apportare dei miglioramenti o fissare i bug. Il codice illegibile ha un costo reale che viene chiamato “debito tecnico”.
La revisione del codice rappresenta il modo più efficace per scovare i difetti e ancora, di solito “non abbiamo tempo per eseguirla”.

Provenendo da un mondo fatto da zero e da uno, ci piacerebbe credere che le cose siano deterministiche, che possiamo fornire un insieme di input e ottenere, ogni volta, lo stesso output. Il nostro è un “business” giovane e per certi versi primitivo. Non sappiamo molto, tra le metodologie da applicare, su cosa funziona e cosa no e continuiamo a pensare, ogni volta che si presenta una nuova metodologia, di aver trovato la panacea a tutti i mali e che possa risolvere tutti i guai dello sviluppo software. In conseguenza di ciò, subiamo le idee su nuovi cicli di sviluppo che arrivano, si diffondono per poi allentare la loro presa e far posto ad altre idee. Secondo la mia opinione esiste un’eccezione; molte idee delle metodologie agili sembrano nel tempo continuare a mantenere il loro vigore. Mostrano di avere un reale impatto nella produttività e nella qualità del software. Questo perché si focalizzano sui problemi delle persone che lavorano insieme e meno sulle tecnologie adottate.

L’esperienza suggerisce: “Ciò che porta al successo o al fallimento di un progetto software sono i problemi che si presentano nei processi e nelle persone conivolte”. Quindi, il modo in cui lavoriamo giorno per giorno. Gli ingredienti che possono formare la miscela esplosiva sono: chi sono i tuoi architetti, chi sono i tuoi manager e chi sono le persone che compongono il team con cui lavoriamo. Come comunichiamo ma soparattutto, come risolvi i problemi di processo e delle persone quando si presentano. Il modo migliore per bloccarsi su queste questioni è pensare che è tutta colpa della tecnologia adottata e credere che noi possiamo sfondare gli ostacoli sfruttando altre vie. Queste altre vie sono quelle che avranno la probabilità più elevata di farti bloccare in modo definitivo.

Certe volte si forma nella nostra mente l’idea che i nostri manager prendano decisioni stupide e logicamente, raggiungiamo la conclusione che i manager e il management è stupido, come se fosse una conseguenza logica. E’ idea diffusa che nel nostro mestiere se non sei abbastanza in gamba per gestire una tecnologia ti dedichi al mangement. In poche parole il ruolo del manager viene da noi sviluppatori “snobbato”. Analizzando con criticità il ruolo che il manager svolge all’interno di un progetto software deduco che il compito del manager non è affatto stupido (fatto salvo che lui stesso non lo sia come persona in sé) e al contrario alquanto difficile. La gestione è più difficile della tecnologia in quanto non coinvolge fattori deterministici. E’ tutto un lavoro da “indovino”. Se non sei dotato di una buona intuizione molto probabilmente prenderai decisioni stupide.

Avendo raggiunto questo punto dell’articolo, quando iniziamo un nuovo lavoro con la testa piena di conoscenze tecniche, derivate dagli ultimi due anni di esperienza e ci guardiamo un pochettino in torno provando a osservare i collegh che ci circondano, possiamo essere tentati ad assumere che ogni persona impiegata nell’azienda ha intrappolato se stessa con pessime idee. Ma a me piace pensare che: “Le cose oggi sono vengono fatte in un certo modo perché i fatti sono andati in quel modo... un passo alla volta”. Dal tuo punto di vista le cose possono sembrare ridicole, ma ricordiamoci che ogni decisione presa fino a oggi è stata presa da qualcuno che ha soppesato il problema e ha scelto quello che sembrava la migliore scelta in quel momemto. Certamente questo punto di vista non risolve i problemi in cui incorriamo ma ci rende più compassionevoli verso le persone che sono impantanate in problemi e concetti di varia natura.

Ci occorrerà fare molti errori al fine di risolvere i problemi. Siamo umili e facciamo domande di continuo.

Automatizzare Firefox con iMacros

2008-01-24T00:31:00.000-08:00

Svolgete regolarmente delle azioni attraverso un browser web? Siete degli sviluppatori che vogliono automaticamente testare l’interfaccia della propria applicazione Web evitando ogni volta di riempire le form o ricordare le password? Oppure, volete loggarvi su tutti i siti che regolarmente visitate ogni giorno con un click? Se ricadete in una di queste categorie, dovreste dare un’occhiata all’estensione iMacros di Firefox.

La società che lo ha sviluppato è la iOpus che offre due versioni del plugin, una versione free e una a pagamento; che come potete intuire mette a disposizione delle funzionalità in più. Tuttavia già la versione free è un ottimo strumento di ausilio al lavoro.

Un volta installato, iMacros aggiunge un nuovo bottone alla barra principale di navigazione. Cliccando su di esso, viene aperta una barra laterale che mostra la lista di tutte le macro già registrate, oltre ad alcuni bottoni e tab che controllano le macro.

Ecco alcuni esempi di cosa è possibile fare con iMacros:

E’ possibile evitare di controllare giornalmente dei siti, ricordarsi le password di ogni sito, riempire form. Tutte le informazioni vengono memorizzate in formato testuale. Le password vengono memorizzate in modo sicuro con crittografia AES a 256 bit.

E’ possibile automatizzare il download di immagini, file, o addirittura di intere pagine Web. Possiamo anche automatizzare l’upload di dati verso un sito Web.

Con il comando extract, iMacros legge automaticamente dati da un sito Web e li estrartai in un file .CVS

Gli sviluppatori web grazie ad iMacros possono effettuare i test funzionali, di performance e di regressione su applicazioni Web.

Infine, è possibile condividere le proprie iMacros con colleghi e amici semplicemente facendo un bookmark della propria macro e renderla disponibile come link da includere nella propria hompage, blog o intranet. E’ possibile anche utilizzare questa funzionalità per far sì che iMacros riempia le form al posto dei visitatori del nostro sito.

In conclusione, iMacros è un ottimo strumento di ausilio durante lo sviluppo di siti Web. Grazie alle funzionalità che mette a disposizione, permette di automatizzare i test da effettuare sulle interfacce Web con il minimo sforzo. Se coadiuvato con un altro plugin Firefox per il Web Development, non vi occorre altro per analizzare e testare il Web tier delle vostre applicazioni.

Nel caso siate interessati ad altre idee su come utilizzare iMacros potete consultare questa pagina.

di Giuseppe Lo Brutto - TuxJournal.net

lshw: ottenere il profilo hardware del proprio PC

2008-01-11T00:58:00.000-08:00

Recentemente ho avuto bisogno del profilo o meglio delle specifiche hardware delle macchine che di solito uso. Come possiamo ottenere un profilo completo delle nostre macchine tramite software libero ed open source?

Avendo un po di conoscenza dei sistemi Linux, la prima cosa che salta in mente è quella di andare a guardare nelle directory /proc/cpuinfo e /proc/meminfo per ottenere informazioni circa CPU e RAM grazie ai seguenti comandi:

cat /proc/cpuinfo > myhwprof.txt
cat /proc/meminfo >> myhwprof.txt

Prutroppo, il risultato di questi comandi è né completo, né presentabile. Per esempio, un profilo del sistema hardware deve contenere almeno la marca della macchina, il modello, interfacce hardware come quella wireless e Ethernet LAN, più altre informazioni.

Dopo varie ricerche mi sono imbattuto nel comando lshw da eseguire da linea di comando. lshw è un piccolo strumento per estrarre dettagliate informazioni sulla configurazione hardware delle macchine. Può riportare informazioni dettagliate circa la configurazione della memoria, le versioni del firmware
installate, la configurazione della scheda madre, la versione della CPU e la sua velocità, la configurazione della cache, la velocità del bus ecc.

Fortunatamente il comando lshw supporta il formato html che è un formato più presentabile se comparato con cpuinfo e meminfo. Da una macchina con Ubuntu come OS lanciamo il comando:

sudo lshw -html > myHardwareProfile.html

Apriamo il file così prodotto con un browser web ed il gioco è fatto.

Giuseppe Lo Brutto

TuxJournal.net