Debian, Ubuntu, Linux, Gnu, software libero Ubuntu, Quantal Quetzal, Raring Ringtail, Linux, Ubuntulandia, Giochi tag foto 3 Mandelbulber, grafica, multimedia, Linux, Ubuntulandia Conky, Ubuntu, Linux, Ubuntulandia, Quantal Quetzal, Raring Ringtail Python, Ubuntu, Linux, programmazione Ubuntu 13.04, Raring Ringtail, Canonical, Linux Android, Linux, Ubuntu Internet Explorer, Firefox, Chrome, Safari, internet browsers, Ubuntulandia Linux Mint, distribuzioni, Ubuntulandia

lunedì 30 agosto 2010

ImageMagick suite di programmi liberi per la creazione, modifica e visualizzazione di immagini bitmap.

ImageMagick è una suite di programmi liberi per la creazione, modifica e visualizzazione di immagini bitmap.

È distribuita con una licenza compatibile con la GNU GPL ed è disponibile su tutti i principali sistemi operativi.

La suite può essere utilizzata per convertire tra differenti formati di immagine (ne supporta oltre 100), può applicare le più comuni trasformazioni (traslazione, riflessione, rotazione, ecc.), può essere usata per regolare i colori delle immagini, per applicare vari effetti speciali o anche per disegnare testo, linee, poligoni, ellissi o curve di Bézier.


Interfacciamento.


L'utilizzo della suite avviene tipicamente attraverso una serie di programmi con interfaccia a linea di comando.

È possibile sfruttare le potenzialità della suite anche attraverso le interfacce disponibili per tutti i linguaggi di programmazione più diffusi:

Linguaggio Interfaccia
Ada
  • G2F
C
  • MagickWand
  • MagickCore
Ch[3]
  • ChMagick
COM+
  • ImageMagickObject
C++
  • Magick++
Java
  • JMagick
  • Im4java
LabVIEW
  • LVOOP ImageMagick
Lisp
  • CL-Magick
Neko/haXe
  • NMagick
.NET
  • MagickNet
Pascal
  • PascalMagick
Perl
  • PerlMagick
PHP
  • MagickWand for PHP
  • IMagick
  • phMagick
Python
  • PythonMagickWand
  • PythonMagick
REALbasic
  • MBS Realbasic ImageMagick
Ruby
  • RMagick
  • MagickWand for Ruby
  • MiniMagick
  • QuickMagick
Tcl/Tk
  • TclMagick
RPC XML
  • RemoteMagick

Seguono alcuni esempi pratici di utilizzo della suite.


Convertire img1.jpg (formato JPEG) in img2.png (formato PNG):

convert img1.jpg img2.png

Ridimensionare img ad una dimensione di 300x200px:

mogrify -resize 300x200 img

Ridimensionare tutte le immagini con estensione jpg presenti nella directory corrente ad una larghezza di 300px (l'altezza viene determinata automaticamente in modo da mantenere le proporzioni)

mogrify -resize 300x *.jpg

Rimpicciolire img1.jpg della metà e salvarla in un nuovo file, img2.png, con un nuovo formato (png):

convert img1.jpg -resize 50% img2.png

Formatti supportati:

Lettura e scrittura.

  • 8BIM (formato risorsa Photoshop)
  • APP1 (formato risorsa Photoshop)
  • AVS (immagine AVS X)
  • BIE (Joint Bi-level Image experts Group interchange format)
  • BMP (Immagine bitmap Microsoft Windows)
  • CIN (formato immagine Kodak Cineon)
  • CMYK (campionatura grezza di ciano, magenta, giallo e nero (8/16bit a seconda della profondità di colore))
  • CMYKA (campionatura grezza di ciano, magenta, giallo, nero e canale alpha (8/16bit a seconda della profondità di colore))
  • DCX (ZSoft IBM PC Paintbrush multi pagina)
  • DIB (Immagine bitmap Microsoft Windows)
  • DPX (Digital Moving Picture Exchang)
  • EPDF (immagina incapsulata in PDF)
  • EPI (Adobe Encapsulated PostScript Interchange format)
  • EPS (Adobe Encapsulated PostScript)
  • EPSF (Adobe Encapsulated PostScript)
  • EPSI (Adobe Encapsulated PostScript Interchange format)
  • EPT (Adobe Encapsulated PostScript with TIFF preview)
  • FAX (Group 3 FAX)
  • FITS (Flexible Image Transport System)
  • FPX (FlashPix Format)
  • G3 (Group 3 FAX)
  • GIF (CompuServe graphics interchange format)
  • GIF87 (CompuServe graphics interchange format (version 87a))
  • GRAY (Raw gray samples (8 or 16 bits, depending on the image depth))
  • H (Internal format)
  • HTML (HTML con mappa immagine)
  • ICB (Truevision Targa image)
  • ICM (ICC Color Profile)
  • IPTC (IPTC Newsphoto)
  • JBG (Joint Bi-level Image experts Group interchange format)
  • JBIG (Joint Bi-level Image experts Group interchange format)
  • JNG (Multiple-image Network Graphics)
  • JP2 (JPEG-2000 JP2 File Format Syntax)
  • JPC (JPEG-2000 Code Stream Syntax)
  • JPEG (Joint Photographic Experts Group JFIF format)
  • JPG (Joint Photographic Experts Group JFIF format)
  • LOGO (ImageMagick Logo)
  • M2V (MPEG-2 Video Stream)
  • MAP (Colormap intensities (8 or 16 bits, depending on the image depth) and indices (8 or 16 bits, depending n whether colors exceeds 256).)
  • MIFF (Magick Image File Format)
  • MNG (Multiple-image Network Graphics)
  • MONO (Bi-level bitmap in least-significant- -byte-first order)
  • MPEG (MPEG-1 Video Stream)
  • MPG (MPEG-1 Video Stream)
  • MSL (Magick Scripting Language)
  • MTV (MTV Raytracing image format)
  • MVG (Magick Vector Graphics)
  • OTB (On-the-air bitmap)
  • P7 (Xv thumbnail format)
  • PAL (16bit/pixel interleaved YUV)
  • PALM (Palm Pixmap format)
  • PBM (Portable bitmap format (black and white))
  • PCD (Photo CD)
  • PCDS (Photo CD)
  • PCT (Apple Macintosh QuickDraw/PICT)
  • PCX (ZSoft IBM PC Paintbrush)
  • PDB (Palm Database ImageViewer Format)
  • PDF (Portable Document Format)
  • PGM (Portable graymap format (gray scale))
  • PICON (Personal Icon)
  • PICT (Apple Macintosh QuickDraw/PICT)
  • PM (X Window system pixmap (color))
  • PNG (Portable Network Graphics)
  • PNM (Portable anymap)
  • PPM (Portable pixmap format (color))
  • PS (Adobe PostScript)
  • PS2 (Adobe PostScript livello II)
  • PS3 (Adobe PostScript livello III)
  • PSD (Adobe Photoshop bitmap)
  • PTIF (Pyramid encoded TIFF)
  • RAS (SUN Rasterfile)
  • RGB (Raw red, green, and blue samples (8 or 16 bits, depending on the image depth))
  • RGBA (Raw red, green, blue, and matte samples (8 or 16 bits, depending on the image depth))
  • ROSE (70x46 Truecolor test image)
  • SGI (Irix RGB image)
  • SUN (SUN Rasterfile)
  • SVG (Scalable Vector Graphics)
  • TEXT (Raw text)
  • TGA (Truevision TGA image)
  • TIF (Tagged Image File Format)
  • TIFF (Tagged Image File Format)
  • TXT (Raw text)
  • UYVY (16bit/pixel interleaved YUV)
  • VDA (Truevision Targa image)
  • VICAR (VICAR rasterfile format)
  • VID (Visual Image Directory)
  • VIFF (Khoros Visualization image)
  • VST (Truevision Targa image)
  • WBMP (Wireless Bitmap (level 0) image)
  • X (X Image)
  • XBM (X Window system bitmap (black and white))
  • XPM (X Window system pixmap (color))
  • XV (Khoros Visualization image)
  • XWD (X Window system window dump (color))
  • YUV (CCIR 601 4:1:1)

Sola lettura.

  • AFM (Adobe font metrics)
  • ART (PF1: 1st Publisher)
  • AVI (Audio/Visual Interleaved)
  • CUT (DR Halo)
  • DCM (Digital Imaging and Communications in Medicine image)
  • DPS (Display PostScript)
  • DPX (Digital Moving Picture Exchange)
  • FILE (Uniform Resource Locator)
  • FTP (Uniform Resource Locator)
  • GRADIENT (Gradual passing from one shade to another)
  • GRANITE (Granite texture)
  • HTTP (Uniform Resource Locator)
  • ICO (Microsoft icon)
  • ICON (Microsoft icon IMPLICIT)
  • LABEL (Text image format)
  • MPR (Magick Persistent Registry)
  • MSL (Magick Scripting Language)
  • NETSCAPE (Netscape 216 color cube)
  • NULL (Constant image of uniform color)
  • PDB (Pilot Image Format)
  • PFA (Adobe Type 1 font file)
  • PFB (Adobe Type 1 font file)
  • PFM (Adobe Type 1 font file)
  • PIX (Alias/Wavefront RLE image format)
  • PLASMA (Plasma fractal image)
  • PWP (Seattle Film Works)
  • RLA (Alias/Wavefront image)
  • RLE (Utah Run length encoded image)
  • SCT (Scitex HandShake)
  • SFW (Seattle Film Works)
  • STEGANO (Steganographic image)
  • SVG (Scalable Vector Graphics)
  • TILE (Tile image with a texture)
  • TIM (PSX TIM)
  • TTF (TrueType font)
  • WMF (Windows Metafile)
  • WPG (WordPerfect Graphics)
  • XC (Constant image uniform color)
  • XCF (GIMP image)
Screenshots .







fonti: Wikipedia & ImageMagick

Se ti è piaciuto l'articolo , iscriviti al feed cliccando sull'immagine sottostante per tenerti sempre aggiornato sui nuovi contenuti del blog:


Linux come server Internet: applicazioni di un sistema operativo Unix-like per realizzare un ISP.

Introduzione

Il Linux è un sistema operativo distribuito tramite la licenza della GNU e quindi disponibile gratuitamente e con il sorgente ricompilabile.


In questo articolo si vuole presentare un esempio di applicazione professionale del Linux per la realizzazione di un ISP (Internet Service Provider) in Udine.


Struttura della rete
La rete interna della ditta è costituita da due macchine principali, il System server e il Web server, entrambi utilizzanti Linux.


Il system server svolge le funzioni di:

  • modem server - ossia gestire i collegamenti in ingresso effettuati tramite modem, la gestione del protocollo SLIP, l'identificazione degli utenti e il log delle attività
  • file server - gestione di un sito ftp anonimo per l'interscambio dei file di pubblico dominio e di un sito ftp con password per lo scambio di files tra utenti autorizzati
  • mail server - gestione della email e dei fax in ingresso
    Il Web server viene utilizzato come server Web tramite il sistema Apache e per l'editing e l'aggiornamento delle pagine html sotto X11. A tale scopo vengono utilizzati diversi tool di pubblico dominio e realizzati internamente (per la generazione della struttura di base delle pagine Web, per la strutturazione delle pagine stesse e per l'editing delle immagini).
    A questi server si affiancano altre macchine non direttamente connesse alla rete, utilizzate per il collaudo delle nuove configurazioni software e per la compilazione off-line di eventuali nuovi programmi.

    Struttura del Modem server
    Il modem server è un PC 486/DX4 a 100MHz, che collega un insieme di modem esterni sia su linea analogica che (prossimamente) su linee ISDN. A questi collegamenti si affianca un cavo numerico a 64Kbit/sec. che costituisce il collegamento Internet con l'esterno. Il cavo si affaccia su un DCE Telecom che collega il cavo numerico a un router Cisco 2500. Il router è collegato alla rete tramite una interfaccia 10BaseT Ethernet su cui si collegano le altre macchine.

    Il server utilizza due schede multiseriali da 4 porte più altre schede seriali e parallele singole. La gestione dei modem viene effettuata tramite la mgetty+sendfax, che provvede alla gestione dei modem sia per il collegamento dati (default) che la ricezione/trasmissione dei fax. Il sistema notifica l'amministratore del sistema dell'arrivo dei fax tramite un messaggio di email standard diretto a un utente fittizio (fax administrator) e tramite la conversione automatica del fax in un formato standard visualizzabile direttamente.

    Sul server sono stati installati un insieme di pacchetti che contabilizzano l'accesso e consentono il log delle operazioni effettuate, provvedono alla selezione automatica degli utenti autorizzati all'ingresso in funzione delle fasce orarie e automatizzano le operazioni di routine mediante una serie di script eseguiti via CRON. Sono stati inoltre realizzati degli script personalizzati per il backup e per la visualizzazione dei collegamenti.

    Le prestazioni del sistema sono particolarmente buone anche sotto carico pesante; le percentuali di utilizzo del sistema raramente eccedono il 5% sia per il system che per lo user time. In alcuni casi si è riscontrata una certa instabilità dovuta probabilmente a una non corretta sistemazione del sendmail (in particolare la cache). La velocità dei collegamenti via modem si è rivelata di gran lunga superiore a sistemi analoghi (Windows NT).

    Il Web server
    Il web server è un sistema Pentium 90 con 16MByte di ram, che viene utilizzato sia come Web server che come piattaforma X11 per l'editing e il preview delle pagine html. Il server utilizzato è il sistema public domain Apache 0.8.14, che si è distinto in modo particolare per la velocità e lo scarso impiego di risorse dimostrato. Il sistema impiega infatti un algoritmo di "minimal fork" che consente di evitare il rallentamento tipico dei server Web CERN e NCSA sotto carico pesante (richieste multiple di pagine, chiamata di scripts esterni con l'interfaccia CGI, ecc.). Il window system impiegato è l'X11R6 con fvwm come window manager, di cui viene utilizzata la icon bar per consentire l'accesso veloce ai programmi più usati. È in corso di verifica un window manager alternativo chiamato bowman che consente di ricreare sotto X11 il look and feel del sistema NeXT, dando una maggiore usabilità al tutto.

    A questi server si affiancherà a breve una macchina utilizzata per la dimostrazione del servizio e per consentire l'editing contemporaneo da parte di due collaboratori diversi delle pagine salvate sul server Web. Tale macchina sarà un 486DX4/100 con 16 MByte di ram e una scheda grafica accelerata ET400W32, in modo da garantire buone prestazioni di velocit&agrave.

    Conclusioni
    Il Linux si è dimostrato una alternativa valida e funzionale sotto tutti i profili, sia come funzionalità che come costo complessivo (software + hardware necessario). Alcuni problemi possono venire dalla non corretta configurazione del sistema o dall'impiego di componentistica di basso costo, che si traduce successivamente in problemi di affidabilità della macchina nel suo complesso.

    Il Linux si è quindi rivelato nel complesso affidabile, di basso costo e (grazie alla disponibilità dei sorgenti) molto flessibile e adattabile alle diverse circostanze. La grande attività di sviluppo che circonda questo sistema operativo garantisce un costante upgrade del software e la disponibilità di tutti i pacchetti necessari alla realizzazione di un server dotato di tutte le funzionalità richieste dalla clientela professionale.

    fonte: Pluto Journal

    Se ti è piaciuto l'articolo , iscriviti al feed cliccando sull'immagine sottostante per tenerti sempre aggiornato sui nuovi contenuti del blog:

  • venerdì 27 agosto 2010

    Tao e Open Source; lo Zen e l'arte della stabilità dei personal computer.

    TaijituE' doverosa una premessa: se cercate un articolo tecnico o siete troppo presi dal vostro lavoro saltate pure a piè pari la lettura di questo articolo: non vi porterà nulla e vi farà perdere del tempo prezioso.


    Per tutti gli altri questo articolo può essere una lettura atipica, con la quale non ho la presunzione, o la speranza, di insegnare qualcosa di nuovo ma spero comunque di fare tornare a tutti un pezzo di sorriso.


    Penso che a tutti coloro che hanno a che fare con l'informatica sia capitata, prima o poi, almeno una giornata nera. Ma veramente nera! L'idea di base per questo articolo nasce da una di queste giornate. Alcuni utenti avevano involontariamente distrutto mesi di lavoro di alcuni sistemisti (compreso il sottoscritto).

    Una volta rientrato dal lavoro non avevo, di conseguenza, molta voglia di passare la serata leggendo riviste di informatica. Avendo appena terminato la lettura di un libro non avevo nuove letture disponibili, così sono andato recuperare una lettura non ancora conclusa: un vecchio libro di Bruce Lee intitolato "The Tao of Jet Kune Doo".

    Il giorno dopo, ripensando ad alcuni passi letti, mi sono reso conto che non avevo mai approfondito il significato della parola Tao usandola in senso generico (ed errato); quindi ho curiosato su Wikipedia e su qualche altro sito per saperne almeno un po di più.


    Man mano che procedevo nella lettura delle definizioni, di Tao e Taoismo, trovavo dei precetti, dei principi e delle definizioni che potevano essere calati nel contesto dell'informatica. Devo subito spiegare che la pagina che potete trovare oggi su wikipedia è diversa da quella da me letta per la prima volta un anno e mezzo fa, e che, io stesso, ne ho, nel tempo, stampate almeno tre revisioni completamente diverse fra di loro nella forma anche se, sostanzialmente, di uguali contenuti. Tali diverse revisioni in alcuni casi hanno cancellato quelle espressioni che più mi avevano colpito, per cui cercherò di riportarle partendo sia dal materiale che troverete in rete, sia da quanto avevo stampato, sia da altre fonti che nel frattempo ho consultato.


    La traduzione letterale di Tao non é univoca. A questa parola vengono attribuiti molti significati in quanto é una parola in cinese antico che può essere tradotta più o meno come "La Via", "Il percorso" o "La ricerca". Quasi unanimamente si concorda che la destinazione di tale percorso é la saggezza; si tratta quindi di un percorso, un cammino, in cui la cosa più importante non è la destinazione ma il cammino stesso inteso come crescita fisica e spirituale.


    Quando si desidera entrare in un progetto open source spesso viene richiesto di iniziare sottoponendo delle piccole patch, per poi passare ad una partecipazione sempre più attiva nel progetto, tale processo è appunto un percorso di crescita che, al di là del valore del progetto stesso, assume valore in quanto ci richiede di progredire superando i nostri limiti. Non si tratta di un analogia con quanto esposto per il Tao si tratta proprio dello stesso percorso e tale affermazione sarà più chiara proseguendo nella lettura.


    Nella filosofia taoista tradizionale cinese, il Tao ha come funzione fondamentale quella di rappresentare l'universo nella sua totalità ed i suoi precetti sono poi stati riversati nel buddismo e nella filosofia zen.



    Alcuni dei precetti fondamentali asseriscono che:

    • Il Tao ha provocato la creazione dell'Universo
    • Il Tao è l'energia che fluisce attraverso tutte le cose, tutta l'esistenza
    • Ogni cosa nell'universo è il Tao
    • Il Tao circonda ogni cosa sottoforma della natura
    • Ogni cosa è ciclica

    Se i precetti fin qui riportativi confondono sappiate che è nella natura del Tao di essere sfuggente fin dalla definizione. Tale condizione viene complicata dal fatto che i testi base del Tao sono scritti in cinese antico. Tale lingua, a quanto pare, veniva scritta senza le vocali e senza segni di punteggiatura per cui la stessa parola può assumere vari significati a seconda delle vocali attribuite ad essa, ed una frase può avere senso diverso in base a come le parole vengono ragruppate.


    Il Tao è, quindi, totalmente astratto ed indefinito e viene sempre spiegato con metafore. Una delle più comuni nelle sue varie forme riguarda il concetto di vuoto. Il vuoto non ha la stessa valenza che assume nelle filosofie occidentali, ove rappresenta una assenza, una mancanza ed ha conotati negativi; al contrario nel Tao il vuoto è più importante dell' opera o dell' ogetto compiuto in quanto nella filosofia taoista esso rappresenta il "potenziale ancora da esprimere".

    In tale contesto un vaso viene ritenuto importante per la sua capacità di contenere (il suo vuoto) più che per la sua estetica di oggetto finito.

    Il foglio bianco ha valore in quanto può essere riempito con un' opera d'arte.
    A questo punto tento una prima analogia con l'informatica: il programma che state iniziando a scrivere potrebbe essere, e potenzialmente lo è, il migliore del mondo. L'opera compiuta verrà valutata, invece, per ciò che avrete ottenuto e potrebbe assumere valore minore a quello potenziale.

    Quindi la prossima volta che iniziate un nuovo lavoro provate a guardare non tanto il traguardo da raggiungere, magari con tempi stretti e obiettivi assurdi, ma la potenzialità di fare un qualcosa di eccezionale.

    Tenete inoltre sempre presente che il nuovo lavoro potrebbe portare con se delle innovazioni e quindi una fase di crescita che come già enunciato ha comunque un valore intrinseco che và apprezzato.

    Proseguendo con la lettura di Wikipedia si trova il seguente passo:

    - Un'idea ricorrente nel Libro della Via e della Virtù, una delle opere fondamentali sul Tao, è quella del lasciar fare. Se si lascia che la natura faccia il suo corso e i suoi diecimila esseri seguano la propria strada, essi cresceranno e si moltiplicheranno. Se non si cerca di governare gli uomini, loro si organizzeranno nel modo migliore possibile. Questo mi ricorda l'Open Source nella sua natura di autogoverno, nella quale si cala anche l'abilità dei responsabili di progetto di lasciare che il loro gruppo si organizzi secondo la sua natura. Il concetto di assecondare il corso delle cose e lasciare che esse seguano il loro percorso naturale è un concetto molto forte nel Tao ed è chiamato il principo del wu wei (azione tramite inazione). La flessibilità dei gruppi di sviluppo Open source permette di assecondare tale principio molto più facilmente di quanto avvenga nelle aziende nelle quali si sviluppa codice proprietario in quanto quest'ultime sono spesso condizionate da necessità di mercato che obbliga a volte il progetto su vincoli molto restrittivi.

    Un'altra definizione che mi ha colpito è la seguente:

    - "La ricerca del Tao è la ricerca dell'essenziale..."

    Non so voi ma a me questa frase, che in molti passi è riportata in senso assoluto così com'è, ha fatto venire subito in mente l'acronimo KISS che stà per Keep It Simple, Stupid, ossia "mantienilo semplice, stupido" che è anche uno dei concetti base dell'extreme programming e che viene riportato anche da Eric S. Raymond nel suo "The Cathedral and the Bazaar" nel passo che segue:
    "La perfezione (nel design) si ottiene non quando non c'è nient'altro da aggiungere, bensì quando non c'è più niente da togliere.
    Quando il codice diventa migliore e più semplice, allora vuol dire che va bene".
    Voglio far notare, in proposito, che codice semplice non vuole dire codice banale. Chi programma da molto tempo sà benissimo che il codice semplice è difficile da ottenere ed è tutt'altro che banale.


    Chi pensa che i miei paragoni siano azzardati sappia che non sono una novità o una mia invenzione e che l'informatica e Tao sono spesso stati accomunati in passato. Voglio citare ad esempio "The Art of Unix Programming" sempre di Eric Raymond. Questo libro, che è un testo sacro per molti programmatori, in origine si intitolava "The Tao of Unix Programming" e il suo contenuto è infarcito di riferimenti alla filosofia zen tanto che il sesto capitolo ha un paragrafo intitolato "The Zen of Transparency" ed esalta il minimalismo di una programmazione chiara e trasparente nell'ottica di ottenere un facile debug successivo. Minimalismo che ci riconduce fra l'altro all'essenzialità di cui si diceva sopra.


    In lingua italiana trovate, invece, uno scritto più specifico intitolato Zen e arte della programmazione ove ritrovate, accanto ad una buona introduzione generale, un analisi di alcuni frammenti di codice dal punto di vista della filosofia Zen. E' interessante notare come un buon codice sia riconoscibile da fattori quali ritmo e equilibrio, termini che è molto difficile incontrare in libri di testo di programmazione canonici.


    Un'altra fonte illustre è Larry Wall, l'inventore del Perl che in Open Sources afferma che il "Perl ha il Tao" per via della sua sintassi, concetto ripreso anche nell'articolo "The great Tao of Perl" di vilk.


    In questo caso i paragoni sono, a mio parere, un po' forzati e mostrano (ancora una volta) l'ecletismo di Larry Wall che è famoso tanto quanto la sua abilità di programmatore.


    Un'altro paragone fra i due mondi viene da un bellissimo articolo di Chen Nan Yang intitolato "Il Taoismo dell'Open Source". In tale scritto si evidenzia che il potere del movimento open source è come quello delle gocce d'acqua. Una singola goccia non fa nulla ma migliaia di gocce scavano la roccia e contribuiscono, alla fine del loro percorso, a formare il mare la cui potenza è immensa se paragonata alla goccia iniziale.


    Allo stesso modo il contributo di migliaia di programmatori volontari è in grado di erodere il potere delle industrie del software proprietario (la roccia) e di creare un "mare" di programmi (immagine, a dir poco, poetica).


    Una fra le cose che mi è piaciuto notare durante queste letture è che il Taijitu, il simbolo del Tao (o meglio dello Yin e Yang) è un simbolo duale che rappresenta "la dualità, l'opposizione e combinazione dei due principi base dell'universo Yin e Yang è riscontrabile in ogni elemento della natura: maschio e femmina, luce e oscurità, attività e passività, movimento e staticità". Un simbolo binario quindi e pertanto facilmente riconducibile al mondo informatico.


    Una simile rassomiglianza con i linguaggi binari si può notare anche nei trigrammi che spesso accompagnano tale simbolo o meglio ancora negli esagrammi del Libro dei mutamenti meglio noto a noi come I Ching. Tali esagrammi sono infatti composti esclusivamente da linee intere o spezzate e costituiscono una specie di indice in linguaggio binario per la consultazione dell'oracolo.


    Concludo questa carellata di perle con un commento tratto dal libro "Lo Zen e la cerimonia del te":


    "La prima cosa che uno nota nell'apprendimento della 'via del te' è che nulla viene fatto arbitrariamente; sembra esserci una regola per ciascun movimento della mano o del piede [...] lo studente è forzato a divenire cosciente di ogni movimento che esegue e del posizionamento di ciascun utensile."


    Rileggendo questo passo mi sono ritrovato a sorridere mentre pensavo che un simile rigore farebbe molto bene anche nell'informatica.

    Aspetto vostri commenti e le vostre opinioni su queste riflessioni; penso che su questo argomento ci potrebbe essere ancora molto da dire...

    Riferimenti bibliografici.

    Wikipedia: Taoismo

    Wikipedia: Tao

    Extreme programming simple rule

    Tao Te Ching (Il libro della via e della virtu) di Lao Tse

    The art of Unix Programming di Eric S.

    Open Sources

    "The great Tao of Perl" di vilk

    "Il Taoismo dell'Open Source" di Chen Nan Yang

    I Ching (Il libro dei mutamenti)

    Zen e arte della programmazione

    Lo Zen e la cerimonia del te di Kazuko Okakura (1957)

    The Tao of Jet Kune Doo by Linda Lee (1975)

    fonte: Pluto Journal

    Se ti è piaciuto l'articolo , iscriviti al feed cliccando sull'immagine sottostante per tenerti sempre aggiornato sui nuovi contenuti del blog:

    giovedì 26 agosto 2010

    Maven: programmare nel terzo millennio diventerà ancora più piacevole.

    Nella programmazione non si può evitare di scontrarsi, prima o poi, con strumenti per la gestione di progetti. Chi ha una minima esperienza con linguaggi come il C avrà avuto modo di fare i conti con gli autotools, così come chi ha sposato la causa Java avrà probabilmente avuto a che fare con Ant. Maven si propone come una valido sostituto di quest'ultimo, senza limitarsi ad offrire le funzioni basilari rese appetitose condendole con artefatti di dubbia utilità, ma cambiando radicalmente il modo di vedere la gestione di un progetto Java.

    Programmare nel terzo millennio diventerà ancora più piacevole, grazie a Maven.

    Cosa è Maven? A questa domanda non è facile dare una risposta precisa. Maven fornisce un approccio completamente nuovo alla questione della gestione di progetti Java che spazia a 360°, quindi la risposta alla domanda di cui sopra varia in relazione a chi viene posta e all'uso che questa persona fa di Maven.


    Si può però facilmente dire cosa non è Maven. Maven non è solo uno strumento per compilare e testare il proprio codice, è molto di più. Maven non è solo uno strumento per impacchettare e distribuire il proprio codice, è molto di più. Con Maven il nostro progetto può godere ad esempio della generazione automatica della documentazione e di pagine per un potenziale sito web, può usufruire del supporto allo sviluppo in un team e della generazione di report, così come di molte altre caratteristiche che raramente si trovano concentrate in un unico strumento per la gestione di progetti.


    Come riportato in [2], ecco una definizione formale per Maven:


    Maven è uno strumento per la gestione di progetti che prevede un modello a oggetti, un insieme di standard, trattazione per il ciclo di vita di un progetto, un sistema di gestione delle dipendenze e logiche per l'esecuzione di obiettivi in forma di plugin in fasi specifiche del ciclo di vita. Usando Maven si descrive un progetto usando un ben definito modello ad oggetti, sul quale Maven stesso può applicare una logica trasversale a partire da un insieme di plugin condivisi o personalizzati.


    Cosa è, quindi, Maven?


    Maven può essere la risposta per chi cerca un semplice strumento per la compilazione automatica del proprio software così come per chi ha bisogno di un approccio più complesso ed articolato alla gestione di un progetto, riuscendo a sopperire alle richieste e alle esigenze del singolo in un modo tanto semplice quanto completo. Non deve spaventare la sua apparente complessità, di fatto infondata, così come è necessario superare la sensazione di perdita di controllo che qualcuno ha di fronte a Maven e al suo comportamento. Una volta imparato ad apprezzarne le caratteristiche e le funzionalità ogni sviluppatore non vorrà più fare a meno di Maven, neanche nel più classico degli ''Hello World!''.


    Primi passi.


    In [1] è presente una breve introduzione, Maven in 5 Minutes che rende fede alla semplicità e immediatezza di questo strumento guidando il lettore nella sua prima, breve esperienza. Il consiglio è, ovviamente, quello di darci un'occhiata. Purtroppo, per problemi di spazio, non sarà possibile dilungarsi attraverso troppi esempi in questo articolo, quindi verranno citati laddove possibile riferimenti utili in tal senso. Allo stesso pari può essere illuminante leggere Getting Started Tutorial, sempre reperibile in [1], una sorta di guida che approfondisce e completa le tematiche lasciate aperte nella breve introduzione precedente.


    POM.


    Maven descrive il singolo progetto attraverso un file POM (Project Object Model), senza il quale Maven non può fare niente. Il file POM guida l'esecuzione in Maven e definisce in modo chiaro l'identità e la struttura di un progetto in ogni suo aspetto e sfaccettatura.
    Un esempio di file pom.xml in [3] è il seguente:



    4.0.0
    com.mycompany.app
    my-app
    jar
    1.0-SNAPSHOT


    junit
    junit
    3.8.1
    test


    In un progetto gestito con Maven tutto è descritto in un file POM: dipendenze, processo di compilazione, artefatti e fasi secondarie come la generazione di documentazione. Questo è l'analogo dei Makefile per gli autotools o del file build.xml per Ant. Ma a differenza dei suoi illustri colleghi non racchiude codice, non riporta direttive di alcun genere, è un file dichiarativo che racchiude in poche righe un grande potere espressivo sollevando lo sviluppatore dalla necessità di scendere nei dettagli delle diverse fasi.
    Il file POM è diviso principalmente in quattro parti, ovvero:

    • Informazioni generali sul progetto, dove possono essere riportati ad esempio nome e URL, lista degli sviluppatori, licenza e così via.

    • Impostazioni per la compilazione, ovvero dichiarazioni per la personalizzazione del processo di compilazione di Maven come l'aggiunta di plugin, posizione dei sorgenti, parametri di generazione delle pagine per un potenziale sito e via dicendo.

    • Ambienti per la compilazione, ovvero profili utili a differenziare le diverse fasi di lavoro e il comportamento ad esse associato.

    • Relazioni fra POM per l'inclusione di moduli, l'ereditarietà fra progetti legati e quindi attraverso POM multipli, ma non solo...


    Nella pratica ogni POM estende quello che è chiamato il Super POM, contenuto nel file maven-x.y.z-uber.jar all'interno del sistema ed ereditato automaticamente, il quale fornisce un insieme di dichiarazioni standard condivise da ogni progetto. Per brevità non è riportato ma si consiglia di dargli un'occhiata, a partire dal proprio sistema o come riportato in [2] per Maven 2.0.9. Nel Super POM è riportato ad esempio il repository remoto da cui ogni client attingerà per completare ed aggiornare la base locale, la struttura per l'albero delle directory come indicata dallo Standard Directory Layout e molto altro ancora.


    Nella sua semplicità, anche il solo POM riportato nel riquadro precedente mette in campo alcuni dei campi chiave di questo oggetto. Ovviamente non è questo il luogo per discutere la sintassi di un file pom.xml ma questa è ampiamente illustrata sia a partire da [1] che in [2] e [3], ai quali si può fare riferimento per approfondimenti. Ci si accorgerà col tempo che la stesura di file POM è cosa immediata e molto semplice, ma può farsi anche complicata seguendo comunque in modo naturale la curva d'apprendimento dell'utente di Maven.


    Build Life Cycle.

    Il build lifecycle è il concetto centrale intorno al quale si sviluppa Maven. Consiste in una serie di fasi durante le quali si possono avere più operazioni, dette goal, come ad esempio durante la fase di compilazione si avranno una serie di chiamate per compilare appunto un insieme di classi.
    È utile capire fin da subito che alcune fasi sono strettamente legate ad altre e quindi l'invocazione delle prime causerà necessariamente anche l'esecuzione delle seconde. In altri termini, laddove l'esecuzione di una fase sia logica conseguenza di un'altra (come la creazione di un package che segue alla compilazione dei sorgenti, obbligatoriamente) verranno prese in considerazione nell'ordine corretto tutte le fasi che portano a quella richiesta. L'aggiunta di funzionalità nel circuito è possibile tramite l'uso di plugin, i quali possono andare a collocarsi in un punto qualsiasi della filiera produttiva a seconda delle necessità.


    Maven si propone con un lifecycle predefinito che prevede diverse fasi, la validazione del progetto, la compilazione, il test, la creazione di pacchetti e così via. Allo stesso tempo è fornito di un gran numero di plugin per le necessità più disparate, ufficiali e non, i quali contribuiscono ad allargare il parco fasi e aggiungono a quelli appartenenti al core di Maven tutta una serie di caratteristiche come la possibilità di creare file war, automatizzare la generazione della documentazione basata su JavaDoc, creare una firma digitale e tanto altro ancora (si veda a tal proposito [4]).


    Il primo progetto con Maven.

    A questo punto, fornita un'idea di base di cosa è Maven, sarebbe forse opportuno dare anche un esempio che, attraverso alcune semplici istruzioni, illustri come si può facilmente creare un progetto basato su Maven. Questo è però un argomento trattato in più e più articoli apparsi sulla rete ed è ampiamente documentato in ogni suo passo tanto in [2] e [3] quanto in [1], nelle due guide Getting Started in 5 Minutes e Getting Started in 30 Minutes; tutta documentazione facilmente e legalmente reperibile su Internet.


    Per uscire un po' dal coro e al contempo dare un esempio di un progettino basato su Maven, che rispetti la struttura di directory standard proposta e si articoli in un pom.xml completo, viene descritto come approcciare il problema delle applicazioni web. Supponiamo quindi che si voglia dare luogo ad un immancabile Hello World! sul web basato su Maven. La struttura della directory come consigliata in [3] e prima ancora in [1], un po' rimaneggiata e ridotta per soddisfare le necessità in base ai problemi di spazio, è la seguente:

    project-name
    |--> src
    | |--> main
    | |--> java
    | | |--> org
    | | |--> company-name
    | |--> webapp
    | |--> WEB-INF
    | | |--> web.xml
    | |--> index.jsp
    |--> pom.xml

    Il file pom.xml associato può assomigliare al seguente:


    4.0.0
    org.company-name
    project-name
    war
    1.0-SNAPSHOT
    project-name
    project description
    http://www.company-name.org/project-name


    junit
    junit
    3.8.1
    test



    company-name
    http://www.company-name.org


    ${artifactId}-${version}

    Con queste premesse dovrebbe essere sufficiente eseguire Maven package per trovarsi impacchettato sul proprio sistema il file project-name-1.0-SNAPSHOT.war. Il tutto dovrebbe avvenire dopo un po' di tempo durante il quale viene rifocillato il repository locale con i pacchetti mancanti, i quali vengono scaricati da una locazione remota predefinita (questa fase avviene solo al primo utilizzo di Maven, dopo il quale i pacchetti saranno già presenti sul proprio sistema e non si avrà la necessità di scaricarli ancora), e quindi vengono attraversate un certo numero di fasi che portano di fatto alla compilazione.


    Maven e il modello a plugin.


    Nell'ultima sezione si vuole dare una panoramica dello sviluppo di plugin in Maven, ovvero di come sia possibile estendere in modo semplice e veloce le funzionalità di questo strumento adattandolo alle proprie esigenze. Maven, come citato sul sito ufficiale, è di fatto un framework per l'esecuzione di plugin ed effettivamente anche il suo funzionamento di base si appoggia ad alcuni di questi oggetti distribuiti in maniera predefinita col pacchetto.


    Per ampliare le funzionalità di Maven si ha già, nonostante il progetto sia relativamente giovane, una nutrita lista di plugin extra che spazia su ogni tipologia di tematica e ambiente, come si può notare in [4].


    Per tutti i plugin, ufficiali e non, si ha una breve documentazione che rende quindi del tutto vano il tentativo di darne un'introduzione in questa sede, poiché sono in realtà molto semplici da usare e configurare. Più interessante, invece, è l'aspetto di sviluppo di questi oggetti, così da poter aggiungere qualcosa di personale al proprio progetto.


    Discesa al centro di Maven.

    Nello sviluppo di plugin è utile capire come funziona in realtà Maven al suo interno, il che semplifica non poco il resto del compito. Il cuore di Maven si basa su Plexus, un container per gestire e mettere in relazione fra loro i diversi componenti, nato come progetto indipendente e adottato da Maven durante il concepimento poiché altri strumenti dello stesso tipo (anche ad oggi più noti, come lo spring framework) non erano ancora maturi.


    Plexus mette in pratica i principi dell'inversione di controllo (Inversion of Control, o IoC), una modalità di progettazione del software in cui il flusso di controllo è invertito rispetto ai metodi usuali. Come spesso riportato parlando di IoC, esso si basa sul principio di Hollywood: "non ci chiami, la chiameremo noi"; al di là della definizione forse un po' scherzosa, questo significa che in framework di questo genere non si è soliti chiamare i metodi messi a disposizione (come ad esempio nell'uso di librerie) ma piuttosto il proprio software viene invocato sulla base di determinate interfacce, offrendo i propri servizi all'ambiente che lo circonda. Non sarà quindi il proprio codice ad andare a dipendere pesantemente dalla libreria o dal framework utilizzato, quanto piuttosto sarà favorito lo sviluppo di componenti riutilizzabili che vanno ad integrarsi in modo trasparente e senza nessun riferimento esplicito all'interno di un ambiente che provvederà alla loro invocazione ed esecuzione.


    Spostandoci quindi su Plexus, questo lascia all'utente il compito di dichiarare le relazioni esistenti fra insiemi di componenti, i quali si limitano a fornire specifiche interfacce di input/output. Gli oggetti da esso trattati non saranno e non devono essere istanziati dall'utente ma sarà Plexus a farlo e allo stesso modo sarà Plexus a farsi carico della gestione del loro stato e del loro ciclo di vita. Questo, come detto, favorisce il disaccoppiamento fra oggetti e framework e incoraggia lo sviluppo di software riutilizzabile.


    L'idea sostanziale è quindi quella di rimuovere completamente dal codice il trattamento per la creazione e la gestione del ciclo di vita degli oggetti, evitando al contempo ogni sorta di dipendenza dal container in cui si va ad operare. Un altro degli aspetti interessanti è poi quello del Dependency Injection. In container come Plexus è spronata la programmazione basata su interfacce, tale da permettere la configurazione dei componenti e la cattura delle dipendenze che fra loro intercorrono, il tutto in un semplice file xml che definisca chi partecipa e come collabora. L'intuizione, senza scendere ulteriormente in dettagli, è che si possa gestire il ciclo di vita degli oggetti, ad esempio istanziandoli in copia unica (evitando il proliferare dei tanto amati e al contempo criticati Singleton), con conseguente capacità di passarli come argomenti all'invocazione di metodi per altri oggetti, il tutto configurato solo ed esclusivamente via xml (quindi senza interferire col codice). In altri termini, si possono scrivere elementi che non sanno niente l'uno dell'altro e vengono legati fra loro tramite direttive via xml.


    Nei container Java tipici si hanno più tipi di iniezione delle dipendenze ma Maven si appoggia solamente a due di questi:

    • iniezione basata su metodi setter: viene usato un metodo setter di un Java Bean per popolare l'oggetto in base alle sue dipendenze.

    • iniezione basata su scrittura su proprietà: per evitare la chiamata di metodi pubblici inevitabile con l'iniezione basata su metodi setter, si può popolare un componente andando ad impostare un campo di un oggetto direttamente.

    Quanto sopra non può e non vuole essere esaustivo e fatica a tratti anche ad essere chiaro, ma vuole dare un'infarinatura sul cosa sta alla base di Maven e qual è il motore che permette ad esso di funzionare. Già adesso forse è possibile avere un po' più chiaro il funzionamento, capire intuitivamente come vengono trattati i plugin e quindi i mojo in Maven (ovvero da Plexus, che sta di fatto alla base di tutto) e farsi un'idea di come sarà orientato lo sviluppo di nuovi componenti.


    Mojo.


    La componente fondamentale in applicazioni basate su Maven è il Mojo (Maven plain Old Java Object), che va a collocarsi nella filiera produttiva rappresentando un singolo passo per il trattamento del software. Nello specifico non è il singolo mojo ma più mojo che concorrono per uno stesso obiettivo a dar luogo ad un plugin, come ad esempio nel caso del plugin maven-compiler-plugin che comprende i due mojo compile e testCompile. Intuitivamente, guardando la cosa dall'altro lato, se un mojo individua un singolo passo in un processo di generazione allora si può vedere quest'ultimo come l'esecuzione in un ordine fissato di una quantità di mojo per raggiungere un prefissato obiettivo (ogni mojo contribuirà permettendo il raggiungimento di una parte di esso, in base al proprio ruolo).

    Descrittori.


    All'interno di un plugin, intuitivamente, così da permettere a Maven di utilizzarlo in modo corretto all'interno della filiera produttiva, si ha un descrittore che fornisce indicazioni sulla sua struttura e funzione, ovvero il file META-INF/maven/plugin.xml.
    Per la verità, nello sviluppare plugin personalizzati non si avrà quasi mai la necessità di scrivere descrittori, poiché questi possono essere generati automaticamente a partire da annotazioni presenti direttamente nel codice del plugin.


    Sviluppo di plugin.


    Senza scendere ulteriormente in particolari, quanto introdotto dovrebbe essere sufficiente a dare un'idea di come sia al contempo flessibile e semplice da usare il modello a plugin di Maven e, quindi, come sia facilmente estendibile con strumenti personalizzati a seconda dei propri desideri e delle proprie necessità. La stesura di un plugin si riassume di fatto nello sviluppo di una serie di mojo (ovvero di singole classi Java contenenti una serie di annotazioni per la generazione automatica dei descrittori) e poco più, un'operazione che con tutta probabilità non spaventerà ma, piuttosto, stuzzicherà l'interesse e motiverà gli sviluppatori che si avvicinano a Maven.
    Un esempio di mojo, senza una descrizione e spiegazione accurata ma solo ed esclusivamente a titolo informativo, come riportato in [2] è il seguente:

      package org.sonatype.mavenbook.plugins;
    import org.apache.maven.plugin.AbstractMojo;
    import org.apache.maven.plugin.MojoExecutionException;
    import org.apache.maven.plugin.MojoFailureException;
    /**
    * Echos an object string to the output screen.
    * @goal echo
    * @requiresProject false
    */
    public class EchoMojo extends AbstractMojo
    {
    /**
    * Any Object to print out.
    * @parameter expression="${echo.message}" default-value="Hello World..."
    */
    private Object message;

    public void execute()
    throws MojoExecutionException, MojoFailureException
    {
    getLog().info( message.toString() );
    }
    }


    Conclusioni.


    Questa breve gita nel mondo di Maven è finalmente o purtroppo terminata. Qualcuno potrà forse obiettare che in questo articolo si è detto tanto ma non si è detto niente e proprio questo, in realtà, era lo scopo.


    Maven è un mondo relativamente nuovo e abbastanza articolato, può mostrare risvolti complessi ma allo stesso tempo guidare con grazia e semplicità gli utenti che vi si avvicinano in un percorso attraverso un uso immediato, intuitivo e completo fin da subito arrivando ad una consapevolezza più dettagliata delle sue potenzialità. Maven non è forse lo strumento definitivo nel suo campo ma senza dubbio ha tutte le caratteristiche per poter dire la sua e ritagliarsi una discreta fetta di utenza che, per quanto esigua possa essere al giorno d'oggi, sarà contagiosa con la sua soddisfazione.


    La speranza è quella, con questi pochi cenni, di aver trasmesso la completa soddisfazione di chi vi scrive nell'usare Maven in ogni nuovo progetto, da alcuni mesi ad oggi. La speranza è che sia stuzzicata la curiosità e attraverso i riferimenti indicati in bibliografia, liberamente scaricabili dal web come riportato anche sul sito stesso di Maven, il lettore possa muovere i primi passi nel mondo di Maven e chiedersi (come in una nota pubblicità) perché nessuno gliene avesse mai parlato prima...

    Riferimenti bibliografici.

    [1] Apache Maven Project:
    http://maven.apache.org

    [2] Maven - The Definitive Guide:
    Readable HTML and Free PDF Download

    [3] Better Builds with Maven:
    Free PDF Download

    [4] Apache Maven Project (Available Plugins):
    http://maven.apache.org/plugins/index.html

    [5] Plexus:
    http://plexus.codehaus.org/index.html

    [6] Maven Repository:
    http://mvnrepository.com/



    fonte: Pluto Journal



    Se ti è piaciuto l'articolo , iscriviti al feed cliccando sull'immagine sottostante per tenerti sempre aggiornato sui nuovi contenuti del blog:


    lunedì 23 agosto 2010

    Greenie Linux è una distro slovacca basata su Ubuntu che include di default Ubuntu Tweak.

    Greenie Linux è una distro slovacca basata su Ubuntu, ma pur essendo basata su di essa non è un mero clone.

    Installazione del sistema.

    Nella prima schermata non c'è traccia di inglese o italiano, per modificare la lingua di installazione premere prima sull'icona posta sul desktop (quella che riporta la scritta "Instalovat Greenie"), che avvierà l' installazione del sistema, ed alla schermata successiva cambiate la lingua e poi il layout della tastiera.

    In cosa differisce da Ubuntu?.

    Il desktop innanzi tutto, una delle prime cose che si nota, sono i pannelli, decisamente pieni di icone, le due icone sul lato destro del pannello inferiore sono di particolare interesse, quella a destra (la X grande) richiama "xkill", una volta premuta, apparirà un cursore speciale che uccide qualsiasi applicazione semplicemente cliccandoci sopra, molto utile quando un'applicazione non risponde.

    L'altra icona, quella accanto a xkill, una volta premuta, apre la finestra di dialogo "Esegui".

    Ciò che è più impressionante di Greenie è che gli sviluppatori, hanno inserito un sacco di buone applicazioni in questa distribuzione, in effetti, la distribuzione è utile sia agli utenti esperti come per i neofiti.

    Greenie include di default Ubuntu Tweak, con il quale configurare in modo semplice e veloce la distro.

    Greenie Linux è una distribuzione eccellente, tutto quello che dovete fare è andare oltre la barriera linguistica, date una canche a questa distribuzione, anche solo per curiosità, dopotutto questa (la curiosità) è la base del progresso.


    Le novità dell'ultima versione stabile rilasciata:

    Greenie Linux Stanislav Hoferek has announced the release of Greenie Linux 8M, an Ubuntu-based desktop distribution optimised for Slovak and Czech-speaking users: "One month after the release of Ubuntu 10.10, a new release of Greenie has arrived. What is new? From this point on, Greenie Linux is primarily a DVD, as it is no longer possible to fit it onto a CD. Among the more interesting programs included in the release are Google Chromium, GIMP, Pidgin, VLC, Moovida, Pingus, WINE, OpenTTD and many other applications and games. Greenie Center was re-built, new theme (Deepin) is used. Work from inside VirtualBox is much better, documentation was updated a bit and there is also better support for languages other than Slovak and Czech."

    Read the rest of the release announcement (mostly in Slovak, scroll to the bottom of the page for the brief English version).

    Download the live DVD image from here: greenie-8m.iso (998MB, MD5).

    Ultime versioni:

    • 2010-11-08: Distribution Release: Greenie Linux 8M
    • 2010-08-22: Distribution Release: Greenie Linux 7.1L
    • 2010-06-17: Distribution Release: Greenie Linux 7L
    • 2009-11-27: Distribution Release: Greenie Linux 6K
    • 2009-06-10: Distribution Release: Greenie Linux 5J
    • 2009-03-14: Distribution Release: Greenie Linux 4I R3

    Imagehosting at Imageloop

    Imagehosting at Imageloop

    Imagehosting at Imageloop

    Imagehosting at Imageloop

    Imagehosting at Imageloop

    Imagehosting at Imageloop

    Imagehosting at Imageloop

    Imagehosting at Imageloop

    Imagehosting at Imageloop

    Imagehosting at Imageloop

    Crea le tue foto ed immagini come Slideshow per eBay, Netlog, MySpace, Facebook o la tua Homepage!Mostrare tutte le immagini di questo Slideshow





    Se ti è piaciuto l'articolo , iscriviti al feed cliccando sull'immagine sottostante per tenerti sempre aggiornato sui nuovi contenuti del blog:

    sabato 21 agosto 2010

    Mono, un progetto maturo, d'aiuto anche in progetti complessi, da seguire con interesse.

    Mono riunisce molti degli aspetti che si possono trovare in un moderno linguaggio di programmazione orientato agli oggetti. Uno dei vantaggi principali è il fatto che il codice sorgente viene compilato in un linguaggio intermedio noto come CLI (Linguaggio Comune Intermedio) ed eseguito all'interno di un ambiente controllato.

    Il codice così eseguito prende il nome di Codice Gestito. L'esecuzione di codice gestito offre vari vantaggi, molti dei quali saranno già noti a chi programma in Java o in linguaggi di scripting.


    • Meno Errori. In ambienti a compilazione tradizionale è facile che errori di programmazione blocchino in modo inatteso l'esecuzione del programma. Tali errori sono spesso dovuti ad un'errata gestione della memoria, quali la mancata deallocazione di risorse, l'accesso oltre i limiti di un vettore o l'uso di un puntatore nullo. In mono la gestione delle eccezioni e l'esecuzione in modalità gestita evita la comparsa di errori di questo tipo.

    • Garbage Collection. L'esecuzione runtime delle applicazioni ha il pieno supporto alla gestione automatica della memoria. Gli oggetti allocati e non più utilizzati vengono automaticamente distrutti, evitando al programmatore l'aggiunta di distruttori e di codice di deallocazione della memoria.

    • Sicurezza. Tramite la creazione di modelli di dominio e un esteso gruppo di attributi, è possibile specificare tutti i vincoli di permessi necessari a un'applicazione. Ogni programma può specificare i permessi che gli sono necessari e gestire le eventuali eccezioni di sicurezza sollevate in caso di mancanza di autorizzazioni.

    • Nulla è perso. Qualora un'applicazione legacy richieda un accesso diretto all'hardware o l'esecuzione di codice migrato dai linguaggi C/C++, è possibile compilare codice in modalità unsafe e utilizzare i costrutti specifici della programmazione non gestita (uso di puntatori, di riferimenti, gestione manuale della memoria etc).


    Mono facilita anche il riuso di codice esistente tutelando eventuali investimenti pregressi. L'infrastruttura P/Invoke permette infatti l'accesso a tutti i metodi inclusi in librerie dinamiche (dll) esistenti, con poche righe di codice e in modo abbastanza elementare.


    Il maggior vantaggio di Mono è però la riduzione dei tempi di sviluppo software. C#, ad esempio, ha una curva di apprendimento ridotta per i programmatori che vengono dal mondo C/C++ o Java, in quanto condivide con tali linguaggi terminologia OOP e sintassi. In più aggiunge alcune funzionalità che riducono sensibilmente i tempi di sviluppo: l'uso di Delegati ed Eventi, di Proprietà ed Interfacce sono solo alcuni esempi.


    Contrariamente a quanto si può pensare, infine, l'esecuzione di codice CIL all'interno della macchina virtuale mono non è affatto lenta. Mono utilizza un JIT (un compilatore just in time) per tradurre il linguaggio bytecode intermedio in codice macchina. L'evoluzione del jitter e il suo continuo sviluppo ne garantiscono prestazioni simili se non superiori a quello utilizzato per la compilazione Java.


    Più piattaforme e più linguaggi.

    La vera forza di Mono è però la libertà che offre, sia in termini di linguaggi che di architetture. Contrariamente a quanto avviene per la piattaforma .net di Microsoft, Mono supporta Windows, Linux, Mac OS X e differenti architetture hardware tra cui x86, PowerPC e SPARC. Inoltre, le librerie Mono (quali ad esempio gtk#) sono disponibili per tutte queste architetture, e permettono una reale programmazione multi-piattaforma.


    Il runtime comune di Mono (ed il meccanismo di traduzione just in time) permette anche di svincolare il programmatore dal linguaggio. Si può sviluppare pressoché in qualunque linguaggio, da C# a VB, da Java a Python, Fortran, Lisp e Cobol. I linguaggi supportati sono veramente moltissimi (si veda ad esempio http://www.dotnetpowered.com/languages.aspx).


    Alcuni strumenti.

    Mono contiene un discreto numero di strumenti a riga comando che permettono la compilazione e l'esecuzione di codice gestito, oltre che facilitare l'apprendimento del linguaggio C#.


    Mcs.

    mcs è il compilatore C# di mono. Il comando permette di compilare il codice, di includere risorse e collegare librerie di funzioni. Il risultato della compilazione è tipicamente un Assembly (una dll o un exe).


    Mono.

    mono è il comando che permette di eseguire un programma all'interno della macchina virtuale. mono utilizza il Jitter per tradurre il codice IL in codice nativo ed eseguirlo. Di seguito viene illustrato il risultato di mono --version, per il comando mono utilizzato di seguito per alcuni piccoli esempi.


    $ mono --version
    Mono JIT compiler version 1.9.1 (tarball)
    Copyright (C) 2002-2007 Novell, Inc and Contributors. www.mono-project.com
    TLS: __thread
    GC: Included Boehm (with typed GC)
    SIGSEGV: altstack
    Notifications: epoll
    Architecture: x86
    Disabled: non

    monodoc.

    Si tratta del visualizzatore di documentazione incluso con il progetto Mono. Permette di sfogliare la documentazione inclusa con le librerie ufficiali del progetto e di studiare i fondamenti del linguaggio C#. Anche gli assembly installati da terze parti possono includere documentazione visibile da tale programma.

    [monodoc]

    Figura 1: monodoc


    Monop2.

    Nel caso in cui non sia facile trovare documentazione sui metodi o la definizione di una struttura o di una classe, o qualora si sia interessati unicamente all'elenco di metodi e proprietà, può essere d'aiuto il comando monop2. Di seguito un esempio.

    $ monop2 System.Int32
    [Serializable]
    public struct Int32 : IComparable, IComparable, IConvertible, IEquatable, IFormattable {

    public static int Parse (string s);
    public static int Parse (string s, IFormatProvider fp);
    public static int Parse (string s, System.Globalization.NumberStyles style);
    public static int Parse (string s, System.Globalization.NumberStyles style, IFormatProvider fp);
    public static bool TryParse (string s, out int result);
    public static bool TryParse (string s, System.Globalization.NumberStyles style, IFormatProvider provider, out int result);
    public int CompareTo (int value);
    public int CompareTo (object v);
    public bool Equals (int value);
    public override bool Equals (object o);
    protected virtual void Finalize ();
    public override int GetHashCode ();
    public Type GetType ();
    public TypeCode GetTypeCode ();
    protected object MemberwiseClone ();
    bool System.IConvertible.ToBoolean (IFormatProvider provider);
    byte System.IConvertible.ToByte (IFormatProvider provider);
    char System.IConvertible.ToChar (IFormatProvider provider);
    DateTime System.IConvertible.ToDateTime (IFormatProvider provider);
    decimal System.IConvertible.ToDecimal (IFormatProvider provider);
    double System.IConvertible.ToDouble (IFormatProvider provider);
    short System.IConvertible.ToInt16 (IFormatProvider provider);
    int System.IConvertible.ToInt32 (IFormatProvider provider);
    long System.IConvertible.ToInt64 (IFormatProvider provider);
    sbyte System.IConvertible.ToSByte (IFormatProvider provider);
    float System.IConvertible.ToSingle (IFormatProvider provider);
    object System.IConvertible.ToType (Type conversionType, IFormatProvider provider);
    ushort System.IConvertible.ToUInt16 (IFormatProvider provider);
    uint System.IConvertible.ToUInt32 (IFormatProvider provider);
    ulong System.IConvertible.ToUInt64 (IFormatProvider provider);
    public override string ToString ();
    public string ToString (IFormatProvider provider);
    public string ToString (string format);
    public string ToString (string format, IFormatProvider fp);

    public const int MaxValue = 2147483647;
    public const int MinValue = -2147483648;
    }

    Monodevelop.

    È un'IDE avanzata per la programmazione con Mono. Sviluppata in gtk#, deriva dal noto SharpDevelop. monodevelop include parecchie funzionalità di un ambiente di sviluppo integrato avanzato: documentazione integrata, autocompletamento del codice, intellisense, supporto alla compilazione, gestione dei riferimenti (collegamenti ad assembly esterni e non solo).

    [monodevelop nuovo progetto]

    Figura 2: monodevelop nuovo progetto

    [monodevelop intellisense]

    Figura 3: monodevelop IDE con intellisense

    Utilizziamo gli strumenti offerti sino ad ora per compilare una semplice applicazione console. Il classico esempio iniziale per qualunque linguaggio di programmazione è ovviamente HelloWorld. Il programma non farà altro che stampare a terminale un saluto, eventualmente accettando un parametro con il nome dell'utente da salutare. Per farlo, creare un file HelloYou.cs e incollarvi il codice seguente:

    using System;

    public class EntryClass
    {
    public static void Main(string[] args)
    {
    if(args.Length != 1)
    {
    Console.WriteLine("Hello World!!");
    return;
    }
    Console.WriteLine(String.Format("Hello {0}!!", args[0].ToUpper()));
    }
    }

    Quindi lanciare i comandi per la compilazione e l'esecuzione del programma. Il compilatore utilizzato in questo caso è gmcs, il compilatore della versione 2.0 (mcs è quello per la versione 1.0).

    $ gmcs HelloYou.cs
    $ mono HelloYou.exe
    Hello World!!
    $ mono HelloYou.exe gabriele
    Hello GABRIELE!!

    Si può anche complicare il programma e dotarlo di una banalissima interfaccia grafica. In mono è stato aggiunto il supporto alle librerie System.Windows.Forms, che permettono l'uso di controlli e componenti in stile Windows. Si può ad esempio pensare di creare una piccola finestra, con una casella di testo ed un pulsante, che visualizzi un messaggio di saluto una volta inserito il nome e premuto il tasto.

    using System;
    using System.Windows.Forms;

    public class MainClass
    {
    public static void Main()
    {
    Application.Run(new HelloForm());
    }
    }

    public class HelloForm : Form
    {
    private System.Windows.Forms.Label label1;
    private System.Windows.Forms.TextBox tbNome;
    private System.Windows.Forms.Button btOk;

    public HelloForm()
    {
    InitializeForm();
    }

    private void btOk_Click(object sender, EventArgs e)
    {
    MessageBox.Show("Hello " + tbNome.Text);
    }

    private void InitializeForm()
    {
    this.label1 = new System.Windows.Forms.Label();
    this.tbNome = new System.Windows.Forms.TextBox();
    this.btOk = new System.Windows.Forms.Button();
    this.SuspendLayout();

    this.label1.AutoSize = true;
    this.label1.Location = new System.Drawing.Point(11, 9);
    this.label1.Name = "label1";
    this.label1.Size = new System.Drawing.Size(99, 13);
    this.label1.TabIndex = 0;
    this.label1.Text = "Inserisci il tuo nome";

    this.tbNome.Location = new System.Drawing.Point(12, 36);
    this.tbNome.Name = "tbNome";
    this.tbNome.Size = new System.Drawing.Size(259, 20);
    this.tbNome.TabIndex = 1;

    this.btOk.Location = new System.Drawing.Point(14, 75);
    this.btOk.Name = "btOk";
    this.btOk.Size = new System.Drawing.Size(75, 23);
    this.btOk.TabIndex = 2;
    this.btOk.Text = "Ok";
    this.btOk.Click += new System.EventHandler(this.btOk_Click);

    this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
    this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
    this.ClientSize = new System.Drawing.Size(284, 105);
    this.Controls.Add(this.btOk);
    this.Controls.Add(this.tbNome);
    this.Controls.Add(this.label1);
    this.Name = "HelloForm";
    this.Text = "HelloYou";
    this.ResumeLayout(false);
    this.PerformLayout();
    }
    }

    Si osservi come venga facilmente aggiunto l'evento di pressione del tasto: è sufficiente utilizzare l'operatore += per aggiungere un delegato che si occupi della gestione dell'evento OnClick del pulsante. Per compilare il programma è necessario includere l'opzione -pkg:dotnet affinché venga gestito correttamente il riferimento alle librerie windows forms del framework 2.0.

    $ gmcs HelloWin.cs -pkg:dotnet
    $ mono HelloWin.exe

    Di seguito una immagine del programma in esecuzione.

    [hellowin]

    Figura 4: hellowin

    Infine, visto che precedentemente è stato citato gtk#, vediamo anche un piccolo esempio con un'interfaccia diversa. In questo caso nella finestra principale appare un solo pulsante, premuto il quale il saluto viene visualizzato sulla console. Di seguito viene riportato il codice del programma e un'immagine illustrativa del suo funzionamento.

    using System;
    using Gtk;

    public class MainClass
    {
    public static void Main (string[ ] args)
    {
    Application.Init( );

    Window w = new Window ("Hello Gtk");
    Button b = new Button ("Ok");

    b.Clicked += new EventHandler (Button_Clicked);

    w.Add (b);
    w.SetDefaultSize (200, 100);
    w.ShowAll();

    Application.Run ( );
    }

    static void Button_Clicked (object o, EventArgs args)
    {
    System.Console.WriteLine ("Hello, World!");
    }
    }

    Si compila il programma, dando il riferimento alle librerie gtk#.

    $ gmcs HelloGtk.cs -pkg:gtk-sharp-2.0
    $ mono HelloGtk.exe

    Ed ecco il risultato.

    [hellogtk]

    Figura 5: hellogtk


    Conclusioni.

    Con la versione 2.0 Mono ha incluso il supporto a un notevole numero di librerie ed effettuato molti miglioramenti rispetto alla versione precedente. Si comincia dalle API con compatibilità Microsoft, come ADO.NET 2.0 (accesso ai database) e ASP.NET 2.0 (sviluppo di pagine web e webservice), Windows.Forms 2.0 per la creazione di applicazioni desktop, e si prosegue con una versione rivista di System.Core che fornisce il supporto per Language Integrated Query (LINQ).

    A seguire, le API Mono, che vanno da GTK# 2.12 per la creazione di applicazioni desktop su Linux, Windows e Mac OS X, a Mono.Cecil per la manipolazione di file in formato nativo ECMA CLI, a Mono.Cairo e l'API grafica 2D per il rendering in svariate forme, compresi i formati postscript e PDF, il supporto SQLite e Mono.Posix, una libreria per l'accesso a funzionalità specifiche di Linux e UNIX dall'applicazione managed.

    Si cominciano a trovare in rete parecchi progetti che fanno uso della piattaforma di programmazione Mono per lo sviluppo: dal motore di SecondLife, completamente riscritto, a progetti quali Banshee Media Player, F-Spot Photo Manager, o TomBoy Notes.

    Mono è un progetto maturo, e può essere d'aiuto anche in progetti complessi. L'uso di webservice e di tecniche di programmazione distribuita permettono anche di creare applicazioni web o smartclient di alto impatto e usabilità. Un progetto da seguire con interesse.

    fonte: Pluto Journal



    Se ti è piaciuto l'articolo , iscriviti al feed cliccando sull'immagine sottostante per tenerti sempre aggiornato sui nuovi contenuti del blog:

    Ultimi articoli pubblicati

    RSVP (Raccomandati Se Vi Piacciono)

    Antipixels & Counters

    SIMBA wirepress tua notizia Segnala Feed Andrix Segnala Feed iFeed WebShake – tecnologia Blogstreet - dove il blog è di casaVero Geek iwinuxfeed.altervista.org Add to Technorati Favorites ElencoSiti Aggregatore Il Bloggatore visitor stats Programming Blogs - Blog Catalog Blog Directory Feedelissimo Paperblog : le migliori informazioni in diretta dai blog Notizie Informatiche