Page 1


Visual Basic e .Net su Linux

Gambas e Mono in aiuto agli sviluppatori pigri Con tutti i linguaggi di programmazione che ci sono sotto GNU/Linux perché si dovrebbe voler usare Visual Basic? Presto detto : se siete in grado di scarabbocchiare qualcosa su un pezzo di carta, allora siete capaci di scrivere un programma in Visual Basic, linguaggio di programmazione evoluto e versatile. Molti lo definiribbero addirittura troppo "semplicistico". La caratteristica piú interessante che ha avvicinato un sacco di novizi alla programmazione é stato il suo ambiente di sviluppo visuale che consentiva di essere produttivi fin da subito. Qualcuno potrebbe obiettare : ma Visual Basic é un prodotto Microsoft, perché mai gli sviluppatori hanno cercato di portarlo anche nel mondo di GNU/Linux? Lo scopo del software libero é quello di offrire qualsiasi cosa venga messa a disposizione dal software proprietario, possibilmente facendo anche di meglio. E' proprio quello che il team di Gambas ha cercato di fare.

Gambas é un potente linguaggio di programmazione per piattaforme Unix-like la cui sintassi é basata sul BASIC, ma con estensione agli oggetti. Integra un IDE (Integrated Development Environment), vale a dire un ambiente di sviluppo visuale, scritto in Gambas stesso con il quale é possibile realizzare applicazioni stand-alone con GUI (interfacce grafiche) basate su GTK+ o Qt, interagire con i database piú diffusi (es.: SQLite, PostgreSQL, MySQL), realizzare applicazioni lato server per il web (CGI), usare le connessioni internet, creare file di script, ecc.... Quello che si propone questo progetto é di essere facile da usare e permettere anche a chi ha poca esperienza con la programmazione di iniziare a scrivere programmi di una qualche utilitá. Gambas é un linguaggio interpretato, quindi la velocitá di esecuzione dei programmi sará sempre inferiore rispetto a quella di

linguaggi compilati puri quali ad esempio C/C++. Peró a differenza del vecchio Basic, dove ogni istruzione era analizzata ed eseguita via via che il flusso dell'elaborazione attraversava il listato, Gambas puó creare degli "eseguibili", che altro non sono che archivi non compressi in cui l'applicazione é convertita in uno pseudo-codice a metá frá il linguaggio macchina puro e il codice originale scritto in Gambas. Io programmatore a questo punto conoscendo il Visual Basic posso cimentarmi a sviluppare applicazioni anche sotto ambienti Unix-like! Certo, ma con alcune accortezze. Gambas é nato come alternativa a questo linguaggio e non come un suo clone. Si ritrovano molte similitudini con il Basic, ma per portare le proprie applicazioni scritte per Windows su Gambas é necessario seguire delle linee guida[2] che renderanno il passaggio non cosí traumatico come ci si puó aspettare.

Gambas 2 IDE

Visual Basic e .Net su Linux - Angelo "sYdRo" D'AUTILIA


Visual Basic e .Net su Linux

Gambas e Mono in aiuto agli sviluppatori pigri E .NET ? Forse Visual Basic stá ormai scomparendo dall'avvento del piú blasonato framework .NET. Essendo Gambas non compatibile con VB.NET, ci ha pensato il team di Mono a creare un'implementazione libera/open source dei linguaggi di Microsoft. La possibilitá di avere un framework unico per diversi linguaggi di programmazione e le componenti delle librerie non dipendenti da quello usato, ma astratte anche dal sistema operativo stesso, hanno reso .NET molto attrante agli occhi degli sviluppatori. Mono si é posto come obiettivo proprio quello di creare degli strumenti compatibili. Caratteristiche principali di Mono:

- MultiPIATTAFORMA : Versione per Linux, MacOs X, *BSD, e Windows includendo numerose piattaforme hardware(x86,x8664,ARM, PowerPc) - MultiLINGUAGGIO : C#, Visual Basic 8, Java, Python, Ruby, ecc.. Eseguibili compatibili : sviluppato secondo gli standard ECMA, con compilatore C# incluso. - Compatibilitá con le API di Microsoft : applicazioni ASP.NET, ADO.NET e Windows.Forms 2.0 vengono eseguite senza ricompilazioni. A differenza di Gambas, Mono non ha un IDE specifico. Esiste pero' MonoDevelop[4] arrivato ormai alla versione 2.2(beta) disegnato per C# e altri linguaggi del framework

.NET. Non é l'unico, infatti alternativa validissima é GTK#[5] (GtkSharp), toolkit ad interfaccia grafica per lo sviluppo di applicazioni Mono utilizzando le librerie GTK+. Molte sono le applicazioni realizzate con queste librerie e tra le piu' conosciute abbiamo Banshee, Beagle, F-Spot, Tomboy e tante altre. Giusto per completezza a quanto detto, si segnala questo ottimo articolo, che spiega cos'é mono e perché potrebbe essere fruttoso utilizzarlo: http://guiodic.wordpress.com/2009 /06/13/due-parole-su-mono-e-sulperche-non-e-necessariamente-ilmale/

Schermata di MonoDevelop

Riferimenti: [1] Gambas : http://gambas.sourceforge.net/ [2] Gambas Docs : http://gambasdoc.org/help/doc/diffvb?show [3] Mono : http://www.mono-project.com/ [4] MonoDevelop : http://monodevelop.com/ Visual Basic e .Net su Linux - Angelo "sYdRo" D'AUTILIA


GnuPG

Proteggere la propria identita' e la propria privacy Privacy, ovvero ? Perchè dovremmo, e soprattutto che vuol dire proteggere la propria privacy ed identità? È un argomento variegato quanto importante, ma cercheremo di comprenderne i fondamenti e soprattutto come ciò viene fatto nel mondo del Software Libero con GnuPG. Privacy, identità. Oggi come oggi, avere un po' di privacy è difficile (per non dire utopistico). Ma che vuol dire privacy? Privacy vuol dire, in parole povere, poter comunicare e trasmettere dati (e quindi informazioni, siano essi sensi più o meno importanti) senza che nessun individuo (od organizzazione) possa metterci le mani sopra, per nessun motivo. Che vuol dire invece, proteggere la propria identità? Vuol dire aggiungere un qualcosa di personale a ciò che viene prodotto con il computer, qualcosa che nè un umano nè un calcolatore possa eplicare e che quindi attesti l'autenticità di un documento, di una e-mail, di un'immagine. Come ottenere entrambe le cose? Con GnuPG e la crittografia a chiave pubblica. Come funziona Cerchiamo ora di condensare in poche righe il funzionamento di GnuPG e della crittografia a chiave pubblica. È fondamentale sapere che tutto si basa su due chiavi crittografiche: una pubblica ed una privata. La chiave privata dovrebbe essere tenuta segreta quanto più possibile (infatti non è salvata neanche sul nostro computer, una volta generata, ma viene salvata in forma cifrata) dato che la useremo per apporre una firma “crittografica” alle nostre email e documenti. La chiave pubblica, invece, dovrebbe essere più diffusa e facilmente reperibile possibile. Per questo infatti ci sono dei server che ospitano chiavi pubbliche, e sono il primo posto dove cercare (e pubblicare) una chiave pubblica.

L'uso delle chiavi assume un significato diverso a seconda del contesto... Possiamo dire che le due chiavi sono in un certo senso complementari: se una cifra, l'altra decifra. Basandoci su questo breve e semplice assioma possiamo implementare diverse strategie.

persona? In genere, spesso ci si scambia le chiavi di persona indicandosi a vicenda quale è la propria chiave. Oppure, dato che anche una chiave può essere firmata, possiamo sapere se una chiave è autentica leggendo le firme che vi sono state apposte e se ci fidiamo di chi ha firmato, allora possiamo accettare la chiave.

Firma digitale crittografica Come apponiamo una firma crittografica ad un'email o documento? Semplice! Calcoliamo un hash del documento (un hash è una funzione che genera una serie di caratteri univoci per ogni file, quindi ci consente di verificare l'integrità del documento), lo cifriamo con la nostra chiave privata e lo alleghiamo al documento in fase. Chi riceve il nostro documento può decifrare l'hash utilizzando la nostra chiave pubblica: se la decifrazione funziona, vuol dire che siamo stati veramente noi ad apporre la firma e non qualcun'altro. Una volta decifrato l'hash, possiamo anche controllare l'integrità del documento, e proteggerne lo stesso dalla manomissione. Abbiamo protetto la nostra identità: nessun'altro può mandare documenti a nostro nome!

In pratica Mettiamo adesso in pratica ciò che abbiamo spiegato. Per proteggere la nostra privacy ed identità, dobbiamo dunque: * installare gnupg * dotarci di un paio di chiavi (quindi generarle) * pubblicarle * usarle. L'installazione dipende dal tipo di distribuzione in uso. Con un po' di fortuna apt-get install gnupg farà ciò che serve. Altrimenti venite pure a chiedere come fare sul canale IRC del SaLUG! (#salug! Su irc.freenode.net)

Crittografia e privacy Utilizziamo l'assioma sopracitato per fare alcune cose interessanti: Se si cifra con la chiave privata, si decifra con quella pubblica. Perciò, se ci cifra con quella pubblica, si decifra con quella privata! Se quindi io cifro il mio messaggio con la chiave pubblica di un mio amico, sono sicuro che lui e solo lui potrà decifrarla con la sua chiave privata. In questo modo il nostro messaggio puo' viaggiare tranquillo, in tutta la Grande Rete, e solo il nostro amico (che ha la sua chiave privata, che tiene segreta) potrà leggere il nostro messaggio. Autenticità Ma come possiamo essere sicuri che una chiave appartenga ad una

Generare le chiavi Ci vuole più a dirlo che a farlo ;-P gpg --gen-key Dato che la chiave è personale, ci verranno fatte alcune domande. Rispondiamo. Scegliamo di creare due chiavi RSA (1), lunghe 2048 bit. Per quel che riguarda la scadenza, è una buona idea quella di generare una chiave di test, prendere confidenza con GnuPG e solo dopo, se siamo sicuri, pubblicarla ed estenderne la validità. Se vogliamo fare delle prove, impostiamo pure due-tre settimane o un mese. Oppure 0, in modo che la chiave non scada. Ci chiederà dunque il nostro nome e cognome, il nostro indirizzo email e un commento. Nome e cognome servono per far capire chi siamo, indirizzo email e commento servono per farci riconoscere in caso di omonimia (ci potrebbe essere un Pinco Pallino che fa l'idraulico ed un Pinco Pallino che fa l'agente segreto, per esempio... Anche se l'idraulico potrebbe essere un agente segreto

GnuPG - proteggere la propria identita' e la propria privacy - Emanuele SANTORO


GnuPG

Proteggere la propria identita' e la propria privacy sotto copertura, ma questo e' un altro discorso - Il commento serve comunque a far capire di/con "quale" Pinco Pallino stiamo parlando. Confermiamo (O). Adesso viene un punto importante: inserire una passphrase. Dato che il nostro computer potrebbe essere rubato, o il nostro hard disk clonato (o peggio), non è sicuro mantenere una chiave segreta in chiaro sull'hard disk. Perciò, essa viene crittografata con questa passphrase e salvata sul nostro hard disk. Quando utilizzeremo GnuPG ci verrà sempre chiesta questa passphrase, perchè la chiave privata verrà decifrata e utilizzata su richiesta, e MAI tenuta in chiaro. Ora verranno effettivamente generate le chiavi. Dato che sono casuali, devono contenere dati presi a caso. GnuPG tenterà di generare automaticamente i dati, ma in caso non riesca, ci chiederà aiuto: muoviamo un po' il mouse a casaccio o apriamo qualche file a caso per generare dei numeri a caso. La nostra chiave è generata! Pubblicare la chiave ATTENZIONE: non è un gioco. Una chiave pubblicata non può essere cancellata. Può essere revocata (ovvero marchiata come non più attendibile), ma NON PUÒ ESSERE CANCELLATA! Se vogliamo prendere confidenza con GnuPG prima di pubblicarla, saltiamo questo passo. Per fare un esempio, l'autore ha aspettato ben otto mesi prima di pubblicare la propria chiave - e non ne è affatto pentito. Se abbiamo confidenza con GnuPG, dunque, possiamo pubblicare la chiave: gpg keyserver.linux.it <indirizzo-email>

–keyserver –send-key

Dove al posto di <indirizzo-email> metteremo l'indirizzo che abbiamo usato per generare la chiave. E-Mail e altro Se abbiamo configurato gnupg, ora

dobbiamo usarlo. Per crittografare al volo i files, possiamo affidarci a Kgpg [0] sotto KDE e a Seahorse [1] sotto GNOME. Per le nostre email, invece, dipende dal client. Client come Evolution, Kmail, mutt supportano autonomamente GnuPG, e la firma delle email può essere attivata tramite menù. Per chi usa client come Thunderbird/Icedove e Outlook il discorso è diverso. Per chi usa Thunderbird c'è il plugin Enigmail. Chi usa quella fetecchia di Outlook... Che passi a Thunderbird. Conclusioni Questo è un condensato di molti argomenti... Se vogliamo capire per bene il tutto, niente è meglio della traduzione italiana del “Manuale GNU sulla privacy" [2] E magari un giorno organizzeremo un key-signing party ;-)

Sopra alcune delle proposte inoltrate dagli utenti al contest per il logo di GnuPG... Sotto uno screenshot di Seahorse [1].

Link Utili: [0] Kgpg http://utils.kde.org/projects/kgpg/ [1] Seahorse http://www.gnupg.org/gph/it/manual.pdf [2] Manuale GNU sulla privacy http://www.gnupg.org/gph/it/manual.pdf GnuPG - proteggere la propria identita' e la propria privacy - Emanuele SANTORO


USB Sniffing catturiamo il traffico sul bus USB in pochi semplici passi... In una delle mie prime attivita' di reverse engineering mi e' capitato di voler effettuare lo sniffing del traffico sul bus USB. Quest'attivita' e' possibile grazie a due strumenti: cat (si, proprio quel semplice programmino che usate ogni giorno per leggere i vostri piccoli file di testo...) e usbmon (un modulo del kernel linux). Nella pratica... Dopo aver montato il filesystem di debug (# mount -t debugfs none_debugs /sys/kernel/debug), e' sufficiente caricare il modulo usbmon (# modprobe usbmon) e siamo pronti a sniffare il traffico sull'USB. E' qui che entra in gioco cat! Supponendo di voler sniffare il traffico su tutti i devices USB digiteremo: # cat /sys/kernel/debug/usbmon/0 u Possiamo arrestare la cattura con Ctrl-C. Diverso e' il caso in cui anziche' voler catturare il traffico su tutti i devices volessimo soltanto quello su un particolare dispositivo. E' necessario a questo punto individuare il bus sul quale e' connesso. Per fare cio' cominciamo eseguendo $ cat /proc/bus/usb/devices. Di nostro interesse sono le cosiddette T-Line, ovvero quelle righe che iniziano con T. Da queste, dopo aver riconosciuto il device tramite il vendor, recuperiamo il bus ID. Potete vedere nel listato 1 un esempio dell'output... Questa e' la parte del mio /proc/bus/usb/devices che individua un possibile dispositivo. Bus=01 significa che l'attivita' di sniffing la condurremo sul file /sys/kernel/debug/usbmon/1u. A che servono a questo punto i file 1s e 1t che troviamo nella stessa cartella? Il file 1t (come tutti i file [0-9]t che troviamo)

$ cat /proc/bus/usb/devices â&#x20AC;Ś T:

Bus=01 Lev=00 Prnt=00 Port=00 Cnt=00 Dev#=

B:

Alloc=

D:

Ver= 2.00 Cls=09(hub

P:

Vendor=1d6b ProdID=0002 Rev= 2.06

S:

Manufacturer=Linux 2.6.30-gentoo-r5 ehci_hcd

S:

Product=EHCI Host Controller

S:

SerialNumber=0000:00:1d.7

0/800 us ( 0%), #Int=

0, #Iso=

) Sub=00 Prot=00 MxPS=64 #Cfgs=

C:* #Ifs= 1 Cfg#= 1 Atr=e0 MxPwr=

Ad=81(I) Atr=03(Int.) MxPS=

1

0mA

I:* If#= 0 Alt= 0 #EPs= 1 Cls=09(hub E:

1 Spd=480 MxCh= 6

0

) Sub=00 Prot=00 Driver=hub

4 Ivl=256ms

â&#x20AC;Ś

Listato 1: contenuto di /proc/bus/usb/devices

# cat /sys/kernel/debug/usbmon/0u ... e5649600 3536332575 S Co:3:004:0 s 21 09 0200 0000 0001 1 = 40000000 00000000 e5649600 3536383563 S Co:3:004:0 s 21 09 0200 0000 0001 1 = 10000000 00000000 e5649600 3536387428 C Co:3:004:0 0 1 > e5649600 3536391397 S Ii:3:004:1 -115:16 1 < e5649280 3536931447 S Co:3:004:0 s 21 09 0200 0000 0001 1 = 40000000 00000000 e5649600 3537004010 S Ii:3:004:1 -115:16 1 < e5649280 3537076558 S Co:3:004:0 s 21 09 0200 0000 0001 1 = 40000000 00000000 e5649600 3537152275 S Ii:3:004:1 -115:16 1 < e5649580 3543624294 S Co:3:004:0 s 21 09 0200 0000 0001 1 = 20000000 00000000 ...

Listato 2: cattura dei pacchetti su tutti i bus USB

sono in un formato deprecato gia' dal kernel 2.6.21. Il file 1s (come tutti i file [0-9]s che troviamo) riassume invece lo stato attuale dell'attivita' di usbmon. Interpretare l'output Nel listato 2 trovate un esempio dell'output della cattura su tutti i device. L'output dello sniffing non e' intuitivo... E' necessario documentarsi per comprenderlo. Fondamentale nella mia attivita' e' stata la documentazione del modulo (/usr/src/linux/Documentation/usb/us bmon.txt). Vediamo di effettuare

una rapida panoramica dei principali campi: - il primo campo (nella fattispecie e5649600) e' l'URB tag (ovvero la USB Request Block) ed identifica l'indirizzo della struttura URB all'interno del kernel in esadecimale. - Il secondo, 3236332575 nella prima riga del caso in esame, e' il timestamp. - Piu' interessante dei precedenti e' invece il terzo campo dove S, C o E (i possibili valori) indicano rispettivamente una submission (trasmissione), una callback (risposta al segnale trasmesso), o USB sniffing - Fabio "valvo" VIOLA


USB Sniffing catturiamo il traffico sul bus USB in pochi semplici passi... un submission error. - Il quarto Co:3:004:0 e' l'address specification e consiste di una lettera maiuscola (C - Control, Z Isochronous, I - Interrupt, B â&#x20AC;&#x201C; Block) ed una minuscola (i - input, o â&#x20AC;&#x201C; output) che indicano rispettivamente il tipo di trasferimento e la direzione. Queste lettere sono seguite dal numero di bus (3 nel caso in esame), dall'indirizzo del dispositivo (004) e l'endpoint number (0). - Il quinto campo contiene la URB specific data il cui contenuto dipende dal tipo di URB inviata o ricevuta. Se si tratta di Control Packets o Setup Packets avremo una 's' seguita da 5 campi (bmRequestType, bRequest, wValue, wIndex, wLength come possiamo leggere nelle specifiche dell'USB 2.0). Se si tratta di un trasferimento isocrono avremo il numero di frame descriptor ed i descrittori stessi. - Data length: e' la lunghezza dei dati. E' richiesta nel caso di una submission, nel caso delle callback rappresenta l'attuale dimensione dei dati. - Data tag: se questo tag e' '=' allora usbmon ha catturato dei dati (che troviamo nel prossimo campo). - Data words: finalmente i dati!!! Ecco quindi che un output apparentemente incomprensibile si rivela in realta' abbastanza semplice ;-)

Serve??? Vi capisco... Sono sicuro che vi starete chiedendo a cosa mai potra' servire tale tecnica... Vi faccio il mio esempio: ho ricevuto in regalo un lanciarazzi USB wireless... Funziona(va) solo con Windows ed un programmino freeware. Ovviamente usare software proprietario e' inconcepibile per me quindi mi son dato da fare per cercare un'alternativa che funzionasse su GNU/Linux, ma soprattutto che fosse libera...

Mi sono imbattuto in ahmissile... L'unico problema e' che non si adattava bene al mio lanciarazzi che risultava quindi limitato nei movimenti e... non sparava!!! Lo sniffing USB mi ha permesso di capire i segnali inviati dal software proprietario lanciato in emulazione e confrontarli con i segnali inviati dal programmino GPL... Queste correzioni non sono poi state necessarie con il rilascio della nuova versione di ahmissile, pero'... l'ho scoperto tardi! :-P

Foto tratta dall'album fotografico Flickr di rustybrick e rilasciata con licenza CC Attribuzione - Non Commerciale

Uno dei lanciarazzi grazie ai quali quest'articolo e' venuto fuori...

Link utili sull'USB sniffing

Link utili sui lanciarazzi :-P

The usbmon: USB monitoring framework

- Controllo del lanciarazzi con perl:

- http://people.redhat.com/zaitcev/linux/OLS05_zaitcev.pdf

http://seconrch.cpan.org/~pen/Device-USB-MissileLauncher-

Usbmon: user guide

RocketBaby-1.01/

- http://groups.google.com/group/microdia/web/usbmon-user-guide

- Alternativa pitonosa: pymissile:

- USB sniffing on Linux

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

http://biot.com/blog/usb-sniffing-on-linux

- Ahmissile http://fatal.se/fulhack/ahmissile/

USB sniffing - Fabio "valvo" VIOLA


Introduzione alle OpenGL

La prima finestra

delle OpenGL, ma come si usano? Cosa è OpenGL? OpenGL significa Open Graphics Library ed è semplicemente una specifica libreria per la grafica 3D. Le implementazioni di OpenGL si ritrovano su tutti gli OS oggi disponibili. Esse sfruttano principalmente la GPU (graphical processing unit), tuttavia ci sono delle implementazioni che usano il software per funzionare, come ad esempio le librerie opensource Mesa. Nella pratica questa libreria facilita la vita dello sviluppatore fornendo delle API identiche per tutte le varie implementazioni. Le OpenGL ricevono primitive come punti, poligoni, linee, li trasformano in pixel e ce li presentano magicamente sullo schermo. Per capire quanto OpenGL sia diffuso basti pensare agli innumerevoli bindings che esistono e che sono riportati su [1]. Su linux il supporto OpenGL viene dato attraverso l'estensione GLX del server X. Tramite il driver DRI poi si ha la renderizzazione da parte dell'hardware (l'accelerazione hardware). Le librerie di default su Linux, quando manca l'accellerazione hardware, sono le librerie Mesa.

Bisogna intanto dire che le OpenGL sono accompagnate dall'utility GLUT. Le GLUT comunicano con il sistema di I/O e permettono la creazione di finestre, uso di tastiera e mouse. Permette inoltre di creare sfere, cubi e poligoni in genere. Le GLUT sono interpiattaforma e semplificano di molto le OpenGL. Prima di tutto abbiamo bisogno delle librerie libgl-dev e libglut-dev. Dopo averle installate iniziamo con la finestra base. #include <GL/gl.h> #include <GL/glut.h> void display(void); int main(int argc, char **argv){ glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE); glutInitWindowSize(200, 200); glutInitWindowPosition(100,100); glutCreateWindow("Sample window"); glutDisplayFunc(display); glutMainLoop(); return 0; } void display(void){ glClearColor(0.0,0.0,0.0,1.0); glClear(GL_COLOR_BUFFER_BIT); glLoadIdentity(); gluLookAt(0.0,0.0,5.0,0.0,0.0,0.0 ,0.0,1.0,0.0); glFlush(); }

Questo codice crea una finestra nera base, per ora usiamo questa per capire ogni funzione passo, passo. Si inizia con glutInit, che inizializza la libreria GLUT, dopo si definisce il modo in cui inizializziamo il display, in questo caso a buffer singolo. Dopodichè definiamo lla finestra, la posizione, e il nome. gluDisplayFunc è a funzione che disegna la scena e viene eseguita in base agli eventi ricevuti dalla finestra, glutMainLoop fa partire il main della scena grafica. Analizziamo ora la funzione display. Si inizia impostando a nero il colore del buffer con glClearColor, glClear completa l'opera pulendolo. glLoadIdentity riporta la matrice allo stato originale, quello di default. GluLookAt imposta la telecamera per inquadrare la scena e glFlush forza l'esecuzione di tutte le operazioni in coda. Bene abbiamo finito! Diamo al nostro beneamato gcc il file con il comando: gcc input.c -o input.o -lglut

E via! ./input.o e ammiriamo la nostra creazione. Per ora dobbiamo accontentarci di questa finestra nera. Nei prossimi numeri scopriremo come disegnare figure basilari come cerchi e qudrati.

Riferimenti [1] http://www.opengl.org/wiki/Language_bindings Link Utili http://www.opengl.org http://it.wikipedia.org/wiki/OpenGL Ok, abbiamo parlato brevemente Introduzione alle OpenGL - Diego "joxer" CANDIDO


Sviluppo web con Rails - parte III

Modifica e validazione dei modelli Migrations Il modello Post e' un po' troppo povero per i nostri gusti e le nostre esigenze... Ingrassiamolo un po'! Cominciamo aggiungendo un campo booleano published che, come in tutti i blog engine, permetta di decidere se il post e' ancora una bozza o e' pronto per esser letto da tutti. Sono le migration che ci permettono di modificare un modello, ad esempio aggiungendo un nuovo campo. Non serve quindi rimuovere il modello e ricrearlo o peggio ancora riscrivere da capo l'applicazione!!! Creiamo la migration! $ script/generate migration AddPublishedField

Ok... Date uno sguardo in db/migrate... Visto? E' stata generata una migration (timestamp)_AddPublishedField.rb. Rails e' potente, lo so... Ma non potete pretendere che basti questo perche' Rails capisca le nostre intenzioni! Apriamo il file con un editor di testo $ emacs db/migrate/timestamp_ AddPublishedField.rb

Osserviamo il contenuto prima di modificarlo: e' composto da due funzioni: up e down. La prima conterra' il codice necessario ad aggiungere alla tabella posts la colonna published. La seconda conterra' il codice per riportare la tabella allo stato precedente l'esecuzione della migration: non si sa mai che un giorno ci si pente... :-P Vediamo allora come dovra' essere il nostro file: class AddBoolField < ActiveRecord::Migration def self.up add_column :posts, :published, :boolean end def self.down remove_column :posts, :published end end

Fatto! Eseguiamo la migration e il gioco e' fatto: $ rake db:migrate

Facciamo lo stesso per aggiungere un title per ogni post ed un campo max_comments che consenta di impostare il numero massimo di commenti applicabili ad un post... Ci serviranno per i prossimi esempi... ;-) Validations Abbiamo creato (o meglio, lo scaffold ha creato) il nostro primo modello: Post. Active Record realizza l'ORM (Object Relational Mapping) creando una correlazione fra la tabella posts nel database e il modello Post nel nostro codice. Il nostro modello avra' dunque degli attributi derivati direttamente dai campi dalla corrispondente tabella. Su questi dati e' bene eseguire delle validazioni per controllarne il formato, la presenza, l'unicita' ecc... Per effettuare le validazioni esistono tre metodi principali: il primo consiste nell'utilizzare i metodi di validazione standard di Rails, il secondo fa uso delle espressioni regolari, il terzo si mette in atto con la scrittura di propri metodi di validazione. Analizziamo uno per uno i seguenti approcci prendendo come esempio il modello Post precedentemente citato con i suoi campi message, author, published e timestamps. Validazione standard Un post per essere valido deve contenere un messaggio... Altrimenti che lo scriviamo a fare? Occorre dunque verificare la presenza di dati nel campo message. Come? All'interno del modello (che ricordiamo si trova in app/models/post.rb) aggiungiamo: validates_presence_of :message

Semplice, come tutto in Rails. Validiamo ora l'unicita' del titolo: validates_uniqueness_of :title

Presenza e unicita' non sono le sole caratteristiche che possono essere sottoposte a validazione. Possiamo ad esempio validare il formato:

validates_numericallity_of :max_comments

Validazione con regexp Il nome dell'autore puo' essere un buon esempio di dato da validare con una regular expression. Supponiamo di voler un nome che inizi con una lettera maiuscola che sia seguita da lettere minuscole. Aggiungiamo inoltre che ogni nick deve terminare con un numero. Limitazioni stupide e fastidiose, e' vero, ma che volete, e' solo un esempio! :-P validates_format_of :author, :with => /^[A-Z][a-z]*[09]*$/:

Validazione self-made Che ne dite ora di scrivere un nostro metodo per la validazione? Bene! Lo facciamo subito! Chiediamo al nostro modello di validare il campo max_comments prendendo solamente valori strettamente positivi: def validate errors.add(:max_comments, â&#x20AC;&#x153;should be more democraticâ&#x20AC;?) if max_comments =< 0 end

Nonostante l'esempio sia breve, emergono subito le enormi possibilta' che questa modalita' di validazione offre. Avere un proprio metodo per il controllo dei dati immessi permette di adattare il codice a situazioni anche ben piu' complicate del semplice controllo di positivita'... Immaginate ad esempio di voler inserire un meccanismo di censura che attesti la validita' del message controllandone il contenuto... :-)

Nella prossima puntata: termineremo la breve trattazione sui modelli e ci concentreremo su controller e viste... Stay tuned ;-)

Web Development con Rails - parte III - Fabio "valvo" VIOLA


GNU/Linux Day 2009

Cronaca di una giornata all'insegna del pinguino Meravigliati ed interessati. Ecco due termini per descrivere gli spettatori del Linux Day 09. Circa 400 tra ragazzi delle superiori, professori, universitari, "addetti ai lavori" e non. Un'aula -quasi- piena di gente attenta e partecipe ai talk della mattina e alle postazioni del pomeriggio. Prima il nostro presidente -Fabio Viola- ha introdotto l'evento e raccontato la storia,le origini e i principali vantaggi del Software Libero. Dopo Alberto De Ronzi ( cioè io :P) insieme ad Angelo D'Autilia hanno tenuto una dimostrazione pratica sull'utilizzo di un sistema Gnu/Linux (Ubuntu). Confrontando il software usato su Windows/Mac OS e quello disponibile su Gnu/Linux i ragazzi hanno scoperto come effettivamente tutto ciò che si fa su un sistema proprietario si può fare anche con il software libero. Durante la pausa i banchetti con la documentazione, i cd/dvd, le

magliette e il Salug journal son stati presi d'assalto. Tutti avevano voglia di provare con mano ciò che avevano appena (e nella maggior parte dei casi , per la prima volta!) visto.Durante la demo c'è stato un intervento di Andrea Verardi, presidente del Sum che ha spiegato ai presenti l'utilità dell'utilizzo di licenze libere come le Creative Common. Infine è arrivato il momento tanto atteso,l'ospite d'onore: Alessandro Rubini.Uno dei più grandi e attivi hacker italiani ha parlato della storia della modifica e gestione dei file di testo, fino ad arrivare a parlare di Git e degli strumenti per lo sviluppo condiviso del codice. Un talk tecnico che tutti gli esperti e smanettoni hanno seguito con tanto entusiasmo. Nel pomeriggio gli ospiti hanno provato con mano i vari software che "girano" su Gnu/linux grazie ai pc dei ragazzi del Salug. Tanta gente che curiosando tra le varie postazioni ha toccato con mano la

Scrivere per il SaLUG! Journal

Far sopravvivere un'idea... Il SaLUG! Journal e' una e-zine aperiodica e distribuita per lo piu' in versione elettronica, realizzata da alcuni componenti del SaLUG! (in ogni numero e' presente il nome degli autori ed eventuali collaboratori). L'idea alla base del Journal e' la condivisione della conoscenza... Chiunque apprenda qualcosa di interessante nell'ambito del software libero puo' mettere a disposizione la sua esperienza tramite le pagine di questo giornale. Contribuire e' semplice! Basta seguire alcune semplici linee guida: innanzitutto trattare solo tematiche inerenti il software libero... L'articolo dev'essere in formato odt,

scritto con carattere URW Palladio (Roman, Bold, Italic) dimensione 10. Eventuali righe di codice o comandi vanno inserite con carattere Courier 10 Pitch dimensione 8, grassetto. Nell'articolo vanno correttamente riportati riferimenti e link di supporto. L'impaginazione verra' effettuata con Scribus da alcuni soci del SaLUG!. Se invece vuoi fornire il tuo articolo gia' impaginato, puoi scaricare l'apposito template dal sito www.salug.it, dalla sezione SaLUG! Journal. La condivisione delle idee e' alla base della crescita di ognuno di noi, ma anchequesta iniziativa! Contribuisci anche tu!

potenza del software libero. Contemporaneamente Rubini ha tenuto un secondo talk sul formato elf e gli eseguibili. Anche qui tantissimi geeks hanno seguito il lungo incontro interessati e coinvolti.A far da cornice non poteva mancare il SUM! I "Cats and joe's", hanno suonato in acustico nell'atrio del corpo Y regalandoci un meraviglioso concerto. GNU/Linux Day - Alberto "albey" DE RONZI

Prossime iniziative: 18 Novembre - ore 18.30 Aula M4 de "La Stecca" Facolta' di Ingegneria Geek Evening 0x17 - Wireshark Remo "fenix" Tomasi terra' un interessante seminario tecnico su Wireshark, software per l'analisi del traffico di rete. Il seminario si dividera' in due parti, la prima teorica sul funzionamento e la scrittura di plugin per wireshark, la seconda, pratica, sull'analisi di un plugin realizzato dal relatore, con la cattura di traffico in tempo reale. Ora e luogo possono subire variazioni. Consultare il sito www.salug.it per restare sempre informati!

Licenza Ogni articolo contenuto nel SaLUG! Journal e' rilasciato con licenza Creative Commons 2.5 Attribuzione - Non Commerciale Condividi allo stesso modo. http://www.creativecommons.it

Info Utili - La redazione...

Salug Journal 0x04  

Il giornale del Salug

Read more
Read more
Similar to
Popular now
Just for you