Archivio per la categoria “Articoli”

Il nuovo strumento di compattazione di SpiderMonkey

Questa è la traduzione dell’articolo “°Compacting Garbage Collection in SpiderMonkey” di Jon Coppeard apparso su hacks.mozilla.org. Tradotto da @gialloporpora, QA effettuato da Sara Todaro, @miki64 e qualche suggerimento aggiuntivo di @EdoPut.

Come tutti gli ambienti di programmazione che non richiedono una gestione esplicita della memoria da parte del programmatore, anche SpiderMonkey (il motore JavaScript di Firefox) ha bisogno di un Garbage Collector, cioè di uno strumento che si occupi di analizzare lo heap per liberare le risorse non più utilizzate. Non esiste un metodo univoco o migliore degli altri per l’implementazione di un Garbage Collector e la scelta di quale algoritmo utilizzare dipende dagli obiettivi che ci si propone di raggiungere: implementazioni più “leggere” consentono un minor impiego di risorse macchina a scapito però di una maggiore frammentazione della memoria. Al contrario implementazioni più complesse richiedono un maggiore tempo di esecuzione ma consentono di evitare la frammentazione dello heap.

Gli sviluppatori di Firefox hanno adottato nel corso degli anni diverse implementazioni del Garbage Collector che hanno tenuto conto della sempre maggiore incidenza del codice JavaScript nelle pagine web. Inizialmente il Garbage Collector utilizzava un algoritmo di tipo reference counting, per poi passare a partire dal 2010 all’implementazione di un Garbage Collector di tipo conservativo mark e sweep. Entrambi questi algoritmi richiedono pochissime risorse computazionali, ma hanno il difetto di produrre una frammentazione dello heap.

È così che dal 2013 si è passati , grazie all’implementazione dell’exact stack rooting, a un’implementazione di un Garbage Collector di tipo generazionale sempre basato sul tracing. Grazie a questa modifica del codice è stato poi possibile implementare lo strumento di compattazione. Nell’articolo è spiegato il funzionamento della compattazione, quando viene eseguita, si analizza il guadagno di memoria che si riesce a ottenere e vengono discusse delle idee per migliorarlo ulteriormente.

Per un approfondimento delle tecniche di Garbage Collection si può consultare questo articolo in italiano che tratta l’argomento in generale e approfondisce il caso del Garbage Collector della Java Virtual Machine.

Sommario

La compattazione è una nuova funzione del Garbage Collector di Firefox, disponibile a partire dalla versione 38, che consente di ridurre la frammentazione esterna nello heap JavaScript. L’obiettivo di questa funzione è ottimizzare il consumo di memoria in generale oltre che gestire con maggiore efficienza i casi di memoria insufficiente. Al momento è stata implementata unicamente la compattazione degli oggetti JavaScript, uno solo tra i vari tipi di celle dello heap elaborate dal Garbage Collector.

Il problema

Lo heap JavaScript è composto da 4000 blocchi di memoria denominati arene, ciascuna delle quali è suddivisa in celle di dimensioni prestabilite. Arene diverse sono utilizzate per memorizzare differenti tipi di celle e ciascuna arena contiene celle dello stesso tipo e della stessa dimensione.

Lo heap contiene diversi tipi di celle, incluse quelle destinate agli oggetti JavaScript, le stringhe e i simboli, ma anche celle utilizzate per dati interni come script (per memorizzare il codice JavaScript), shape (per memorizzare la rappresentazione degli oggetti grafici e delle loro proprietà) e jitcode (codice JIT compilato). Di tutte queste, solitamente le celle utilizzate per gli oggetti JavaScript sono quelle che utilizzano la maggiore quantità di memoria.

Un’arena non può essere liberata se al suo interno c’è una cella che contiene dati in uso. Celle allocate nello stesso periodo possono avere dei cicli di vita differenti, talvolta accade quindi che nello heap si trovino più arene ciascuna contenente solo poche celle attive. Lo spazio libero di ciascuna arena può ancora essere impiegato per allocare nuove celle dello stesso tipo, ma sarà inutilizzabile per celle di tipo diverso o per essere reimpiegato dal sistema in caso di memoria insufficiente.

Di seguito è mostrato un diagramma semplificato dello heap con arene che contengono due diverse tipologie di celle.

Diagramma semplificato dello heap

Si noti che se fosse possibile utilizzare lo spazio libero nell’arena 3 per allocare le celle dell’arena 5, si otterrebbe un’intera arena libera.

Misurare lo spazio inutilizzato

È possibile conoscere lo spazio utilizzato da queste celle non più attive visitando la pagina about:memory e premendo il tasto MeasureL’ammontare complessivo di memoria per ciascun tipo di cella è visualizzato nella sezione js-main-runtime-gc-heap-committed/unused/gc-things. Per maggiori informazioni su come interpretare i rapporti della pagina about:memory consultare questo articolo su MDN.

Di seguito uno screenshot dell’intera sezione js-main-runtime-gc-heap-committed con la compattazione del Garbage Collector disattivata che mostra la differenza tra spazio utilizzato e non:

Screenshot dello spazio inutilizzato nello heap

Ho effettuato misurazioni approssimative dell’utilizzo di memoria durante la mia normale navigazione con la compattazione sia attivata che disattivata per osservare le differenze. La procedura per ottenere questi dati è descritta nell’ultima sezione dell’articolo. I dati sono stati rilevati con una cinquantina di schede aperte, tra cui Google Mail, Google Calendar, varie pagine di Bugzilla e altri siti. Questo è il risultato ottenuto:

Totale allocazioni
esplicite
Celle
inutilizzate
Prima della compattazione 1324,46 MiB 69,58 MiB
Dopo la compattazione 1296,28 MiB 40,18 MiB

È possibile osservare una riduzione delle allocazioni esplicite di 29,4MiB (mebibytes). Si tratta solo del 2% rispetto al totale delle allocazioni complessive, ma considerando solo lo spazio occupato dall’allocazione di oggetti JavaScript (al momento gli unici soggetti a compattazione) sale a oltre 8%.

Funzionamento della compattazione

Per recuperare lo spazio inutilizzato il Garbage Collector dovrebbe essere in grado di spostare le celle fra differenti arene, in modo da concentrare le celle attive in un numero limitato di arene e liberare le altre. Certo è più facile a dirsi che a farsi, perché per ogni cella spostata bisognerebbe riaggiornare anche i relativi puntatori. Anche un solo puntatore non aggiornato potrebbe bastare a causare un crash di Firefox.

Questa operazione inoltre è molto dispendiosa in termini di risorse perché richiede l’analisi di un numero non irrilevante di celle alla ricerca dei puntatori da aggiornare. Per questo motivo l’idea è quella di procedere alla compattazione dello heap solo nei momenti in cui si disponga di poca memoria o l’utente non stia utilizzando Firefox.

L’algoritmo di compattazione è suddiviso in tre fasi:

  1. Selezione delle celle da spostare.
  2. Spostamento delle celle.
  3. Aggiornamento di tutti i puntatori con riferimenti a queste celle.

Selezione delle celle da spostare

Ciò che ci proponiamo di fare è spostare il minor numero di dati possibile e di farlo senza riallocare ulteriore memoria, partendo dal presupposto che la memoria a disposizione sia già in esaurimento. Per fare questo inseriamo in una lista tutte le arene che contengono spazio libero, ordinandole in modo decrescente a seconda del numero di celle libere al loro interno. Suddividiamo la lista in due parti a partire dal punto in cui le arene della prima parte contengono abbastanza celle libere per ospitare le celle attive delle arene nella seconda parte. Sposteremo tutte le celle delle arene della seconda parte.

Spostamento delle celle

Allochiamo dunque una nuova cella da una delle arene che non subiranno spostamenti. Il passaggio precedente ci assicura che ci sia abbastanza spazio libero per effettuare questa operazione. A questo punto copiamo i dati dalla posizione iniziale.

In alcuni casi troveremo una cella con puntatori che puntano alla cella medesima: essi verranno aggiornati in questa fase. Il browser potrebbe contenere riferimenti a oggetti esterni, in questo caso utilizzeremo un hook per aggiornarli.

Dopo aver spostato una cella, aggiorneremo la locazione di memoria originale con un puntatore di reindirizzamento che faccia riferimento alla nuova posizione in modo da poterla facilmente ritrovare in seguito. Questo permetterà inoltre al Garbage Collector di identificare le celle che sono state spostate e vedremo come ciò verrà utilizzato nel successivo passaggio.

Aggiornamento dei puntatori alle celle spostate

Questa è la parte più dispendiosa del processo di compattazione. Nel caso più generale, non è possibile conoscere quali celle contengano dei puntatori alle celle che abbiamo spostato, quindi sembra proprio che sia necessario effettuare una scansione di tutte le celle presenti nello heap. Una tale scansione globale dello heap sarebbe davvero dispendiosa in termini di risorse macchina impiegate.

Abbiamo però alcuni metodi per ridurre le risorse impiegate. Innanzitutto si noti che lo heap è suddiviso in più zone: una zona per ogni scheda aperta e altre zone utilizzate dal sistema. Dato che, di norma, le celle non contengono mai puntatori con riferimenti a zone diverse da quella in cui si trovano, la compattazione potrà essere effettuata per zona e non su tutto lo heap. Il caso particolare di celle con puntatori a zone diverse da quella di appartenenza verrà effettuato a parte. La compattazione per zone ci consentirà di suddividere il processo in diverse sezioni incrementali.

In secondo luogo, per costruzione, esistono delle tipologie di celle che non possono contenere puntatori a altre tipologie di celle (a essere precisi ci sono alcune tipologie di celle che non possono proprio contenere dei puntatori), è quindi possibile escludere a priori alcune celle dalla ricerca.

Infine, possiamo parallelizzare questa operazione e sfruttare tutte le risorse della CPU disponibili.

È importante notare che ciò è stato reso possibile solo grazie al lavoro fatto a suo tempo implementando l’exact stack rooting, come descritto in questo articolo del blog Mozilla. Infatti è possibile spostare gli oggetti solamente conoscendo quali locazioni nello stack sono root, altrimenti si corre il rischio di sovrascrivere dei dati non correlati nello stack che potrebbero essere interpretati erroneamente come dei puntatori a celle.

Programmare l’esecuzione della compattazione

Come accennato in precedenza, la compattazione non viene effettuata a ogni ciclo di esecuzione del Garbage Collector. Allo stato attuale dell’implementazione essa viene effettuata nelle seguenti situazioni:

  • è stata utilizzata tutta la memoria e si cerca di fare un ultimo tentativo per liberare dello spazio utile;
  • il sistema operativo genera un messaggio riguardante la gestione della memoria non corretta da parte di Firefox;
  • l’utente non utilizza il sistema per un certo periodo di tempo (per impostazione predefinita questo periodo è attualmente di 20 secondi).

Nei primi due casi la compattazione viene avviata per scongiurare situazioni di memoria insufficiente, mentre nel terzo caso si cerca di ottimizzare la memoria a disposizione senza impattare la navigazione.

Conclusione

Spero che questo articolo sia riuscito a spiegare il problema che ci proponiamo di risolvere grazie allo strumento di compattazione del Garbage Collector e come stiamo cercando di affrontarlo.

Un inaspettato effetto positivo dell’implementazione della compattazione nel Garbage Collector è che ha rivelato alcuni errori nel tracing dei puntatori alle celle. E questo tipo di errori possono generare dei crash difficili da identificare e riprodurre e generare possibili falle nella sicurezza del browser, quindi possiamo considerarlo un ulteriore miglioramento anche da questo punto di vista.

Idee per il futuro

L’introduzione della compattazione è stata un’importante tassello per il miglioramento del Garbage Collector di Firefox, ma non è comunque finita qui. Ci sono ancora molti altri aspetti su cui possiamo concentrarci per migliorarlo ulteriormente.

Attualmente la compattazione viene effettuata solo sugli oggetti JavaScript, ma esistono molti altri oggetti nello heap e estenderla anche a questi potrebbe consentirci di ottimizzare ulteriormente la memoria utilizzata. Una domanda sorge spontanea: è possibile determinare a priori se le celle contengono dei puntatori alle celle che andremo a spostare? Se trovassimo il modo per farlo, le risorse impiegate per la compattazione verrebbero ulteriormente ridotte. Una possibile soluzione è scansionare lo heap in background, ma per farlo si renderebbe necessario individuare le modifiche effettuate alle celle dal mutator.

L’attuale algoritmo del Garbage Collector raggruppa assieme celle allocate in diversi momenti. Solitamente, le celle che sono allocate nello stesso momento hanno una durata simile, motivo per cui questa scelta non è il massimo.

Se riuscissimo a minimizzare i tempi di esecuzione della compattazione sarebbe possibile effettuarla ogni qualvolta il Garbage Collector rilevi un certo livello di frammentazione dello heap.

Come calcolare lo spazio liberato con la compattazione

Per stimare a grandi linee lo spazio liberato grazie alla compattazione è possibile effettuare i seguenti passaggi:

  1. Disattivare la compattazione aprendo la pagina about:config e impostando la preferenza javascript.options.mem.gc_compacting a false.
  2. Al momento attuale è preferibile disattivare la modalità multiprocesso di Firefox dal pannello Opzioni.
  3. Riavviare Firefox e aprire alcune schede. Per guadagnare tempo è presente un’opzione che permette di ricaricare tutte le schede della sessione precedente. Attendere che le pagine vengano caricate.
  4. Aprire la pagina about:memory e effettuare un’esecuzione completa del Garbage Collector facendo clic su Minimize memory usage e successivamente su Measure. Poiché è necessario un po’ di tempo affinché la memoria si assesti, è consigliabile effettuare l’operazione un certo numero di volte per ottenere dei valori significativi.
  5. Annotare l’ammontare delle allocazioni esplicite (Total GC size) e quello di js-main-runtime-gc-heap-committed/unused/gc-things.
  6. Riattivare nuovamente la compattazione impostando javascript.options.mem.gc_compacting a true. Non è necessario riavviare Firefox.
  7. Fare nuovamente clic su Minimize memory usage e successivamente su Measure.
  8. Confrontare le letture con quelle precedenti.

Notare che i valori ottenuti non saranno precisi a causa delle varie operazioni in atto in background, ma rappresentano comunque una buona approssimazione.


Primi passi con Rust

Questa è la traduzione dell’articolo di Szmozsánszky István apparso sul sito hacks.mozilla.orgDiving into Rust for the first time”.

Il logo del linguaggio di programmazione Rust

Rust è un nuovo linguaggio di programmazione focalizzato sulle prestazioni, la parallelizzazione dei processi e la gestione sicura della memoria. Sviluppando un nuovo linguaggio da zero e includendo alcuni dei modelli utilizzati dai moderni linguaggi di programmazione, gli sviluppatori di Rust hanno evitato la necessità di includere un sacco di “zavorra” (codice per la retrocompatibilità) con cui i linguaggi di programmazione meno recenti devono fare i conti. Diversamente, Rust è in grado di fondere la sintassi espressiva e la flessibilità dei linguaggi ad alto livello con il controllo senza eguali e le prestazioni di un linguaggio di basso livello.

La scelta di un linguaggio di programmazione solitamente comporta dei compromessi. Sebbene molti dei moderni linguaggi di programmazione ad alto livello forniscano strumenti per gestire in modo sicuro la programmazione concorrente e la memoria, questo obiettivo viene raggiunto solo utilizzando risorse aggiuntive a runtime (overhead), ad esempio utilizzando un Garbage Collector (GC) e tendono a essere carenti dal punto di vista delle prestazioni e a non offrire il necessario controllo sul codice prodotto.

Per superare queste limitazioni è necessario utilizzare linguaggi di programmazione a basso livello. Però, senza la rete di sicurezza propria di molti linguaggi di programmazione ad alto livello, questo può generare codice fragile e soggetto a errori. Ci si troverà improvvisamente a dover gestire manualmente la memoria, l’allocazione delle risorse e a districarsi con i puntatori pendenti, ecc. Creare del software che sfrutti al massimo il crescente numero di core presenti negli attuali dispositivi è complesso, ancor più complicato è assicurarsi che il codice funzioni correttamente.

Quindi, in che modo Rust riesce a mettere assieme il meglio dei due mondi in un unico linguaggio di programmazione? In questo articolo cercheremo di dare una risposta a questa domanda.

Recentemente è stata rilasciata la versione 1.0 stabile di Rust. Il linguaggio ha già una comunità molto attiva, un crescente ecosistema di librerie (chiamate crate) disponibili tramite Cargo, il package manager, e molti sviluppatori che stanno già sfruttando le sue capacità in svariati progetti. Anche se non si è mai avuto a che fare con un linguaggio a basso livello, questo è il momento giusto per approfondire l’argomento.

La maglietta realizzata per celebrare l’uscita di Rust 1.0 in tutto il mondo.

Rust: ambiti attuali di utilizzo

Rust sembra un’ottima scelta per programmatori abituati a lavorare a stretto contatto con il sistema, ma cosa dire per chi non ha familiarità con i linguaggi di programmazione a basso livello, ad esempio tutti quei programmatori che ricordano solo vagamente le parole “C” e “allocazione dello stack/heap”, magari per averle ascoltate anni fa in un corso introduttivo sulla programmazione? Rust fornisce prestazioni tipicamente ottenibili con un linguaggio di basso livello. Nonostante questo, nella maggior parte delle occasioni la sensazione è quella di lavorare con un linguaggio ad alto livello. Ecco alcuni esempi che mostrano concretamente come utilizzare Rust nello sviluppo delle proprie applicazioni.

Hacking e sviluppo di applicazioni per l’Internet delle cose (IOT)

L’era dell’Internet delle cose (IOT) e l’espansione del movimento dei cosiddetti maker ha portato a uno sviluppo democrativo del mondo dell’hardware. Che si tratti del Raspberry Pi, di Arduino o di uno dei giovani colossi emergenti come BeagleBone o Tessel, è possibile scegliere tra molti linguaggi, inclusi Python e JavaScript, per lo sviluppo del proprio progetto hardware.

In alcuni casi però, le prestazioni ottenute con questi linguaggi di programmazione sono, molto semplicemente, non adeguate. Altre volte, l’hardware scelto non è adeguato all’esecuzione di questi linguaggi di programmazione: processori lenti, con memoria e consumi di corrente ridotti al minimo, richiedono ancora l’utilizzo di linguaggi più vicini a quello macchina. Tradizionalmente il linguaggio di riferimento è sempre stato il C, ma come probabilmente si sarà intuito, Rust è l’alternativa emergente in questo settore.

Rust supporta un’ampia gamma di piattaforme. Sebbene il supporto per alcune di queste piattaforme sia ancora in fase sperimentale, tra esse si possono annoverare l’hardware “generic ARM”, la dev board TIVA di Texas Instruments e anche il Raspberry Pi. Alcune delle schede elettroniche di nuova generazione realizzate per l’Internet delle cose, come la scheda Tessel 2, hanno il supporto per Rust integrato e ufficiale.

Operare con applicazioni di calcolo a elevate prestazioni scalabili su core multipli

Alcuni studi suggeriscono che Rust sia già un’ottima scelta per il calcolo a elevate prestazioni (HPC). Non è necessario riscrivere tutto il codice delle proprie applicazioni in Rust: l’interfaccia per la gestione delle funzioni esterne (Foreign Function Interface o FFI) offre un ottimo binding per il codice C e consente di esporre e richiamare codice in Rust senza overhead rilevanti. Questo consentirà di riscrivere il codice della propria applicazione modulo per modulo, migrando lentamente verso una migliore esperienza per gli sviluppatori, che si tradurrà in prestazioni uguali se non addirittura superiori a quelle del vecchio codice. Inoltre si otterrà una base di codice più gestibile con meno errori, in grado di scalare meglio su un elevato numero di core.

Realizzare applicazioni più veloci

Rust è una scelta ideale per riscrivere parti sensibili delle proprie applicazioni che necessitano di avere alte prestazioni. Grazie all’interfaccia FFI è in grado di integrarsi bene con altri linguaggi di programmazione e dispone di un leggero ambiente di runtime in grado di competere con quelli del C e del C++, anche quando le risorse a disposizione sono limitate.

Nonostante la natura del linguaggio in costante evoluzione, esistono già progetti di una certa rilevanza, applicazioni utilizzate in ambienti di produzione che hanno già fatto buon uso di Rust nel corso del tempo: la startup di Yehuda Katz, Skylight, sfrutta le elevate prestazioni del codice Rust integrato in un pacchetto gem Ruby per la manipolazione dei dati. La versione 1.0 rappresenta un’importante pietra miliare nello sviluppo del linguaggio in quanto non sono previsti cambiamenti rilevanti da qui in avanti. Proprio per questo motivo è possibile consigliare l’utilizzo di Rust anche per progetti importanti.

È possibile guardare il video di Yehuda Katz e Tom Dale in cui spiegano le basi della programmazione in Rust e come loro utilizzano Rust unitamente a Ruby per le loro applicazioni.

Primi passi con Rust

Esistono molte guide che introducono i concetti base di Rust e altre che trattano argomenti più specifici. Ad esempio, nel blog dedicato a Rust, il Rust blog, è possibile trovare molti articoli interessanti su vari aspetti del linguaggio. Esistono anche eccellenti presentazioni introduttivi come quella tenuto all’università di Stanford da Aaron Turon. In questo talk, Aaron spiega in modo brillante i concetti fondamentali e i principi alla base di Rust e può rappresentare il perfetto punto di partenza per un viaggio alla scoperta del linguaggio:

Presentazioni e guide non possono sostituire la scrittura di codice quando si tratta di apprendere un nuovo linguaggio di programmazione. Fortunatamente anche in questo settore esistono molte ottime risorse per imparare a utilizzare Rust. Il libro Rust Book è stato appositamente concepito per aiutare i programmatori a muovere i primi passi con Rust — partendo dall’installazione dell’ambiente di lavoro e dalla creazione del primo programma, rappresenta allo stesso tempo un’approfondita guida di riferimento per tutte le caratteristiche fondamentali del linguaggio.

Un’altra risorsa degna di nota è Rust by Example, in grado di guidare il lettore alla scoperta delle caratteristiche principali di Rust sino ai segreti poteri dei trait, delle macro e dell’interfaccia FFi. Rust By Example offre utilissimi esempi modificabili direttamente nel browser inclusi nei vari articoli. Non è nemmeno necessario scaricare e compilare il codice Rust, poiché è possibile provare, e modificare, il codice stesso direttamente dal browser stando comodamente seduti sul proprio divano di casa. Per lo stesso motivo esiste pure un Playpen online dedicato a Rust.

Non che scaricare e installare Rust sia molto complicato. È sufficiente visitare la pagina principale del sito di Rust e scaricare i file di installazione per il proprio sistema operativo. Il download comprende tutti gli strumenti base per iniziare, come rustc, il compilatore, o cargo, il package manager) e sono disponibili i pacchetti precompilati per tutti i sistemi operativi (Windows, Linux e OSX).

Ma allora, che cos’è che rende Rust così unico? Così diverso?

Lo stile Rust

Probabilmente è proprio il modello di proprietà (ownership) di Rust, non presente in altri linguaggi, che gli consente di essere davvero competitivo, riuscendo a eliminare tutta una serie di errori relativi al threading e alla gestione della memoria, e nello stesso tempo a semplificare lo sviluppo e il debug del codice.

Il modello di proprietà in Rust

Il principio base del modello di proprietà in Rust consiste essenzialmente nel fatto che ciascuna risorsa può appartenere a uno e un solo “proprietario”. Col termine risorsa si può indicare qualunque cosa, da una porzione di memoria a un socket aperto, fino a qualcosa di più astratto come un mutex lock. Il proprietario della risorsa è il responsabile del suo utilizzo, in alcuni casi pu prestarla ad altri utenti e deve, in ultima istanza, occuparsi della sua rimozione. Tutto ciò avviene automaticamente, grazie all’uso di scope e binding: un binding può possedere o prendere in prestito i valori, e dura fino al termine del proprio scope. Quando un binding esce dallo scope, deve restituire il valore preso in prestito oppure rimuoverlo se ne è il proprietario.

La cosa ancor più interessante è che i controlli per il corretto funzionamento del modello di proprietà sono effettuati e forzati dal compilatore Rust e dallo “strumento di controllo dei prestiti” in fase di compilazione e tutto questo produce una serie di vantaggi aggiuntivi.

Nessuna astrazione

Poiché il corretto funzionamento di un programma viene valutato in fase di compilazione, è possibile considerare il risultato ottenuto dopo la compilazione privo di errori tipici della gestione della memoria e della programmazione concorrente, come ad esempio l’utilizzo di puntatori che fanno riferimento a porzioni di memoria che sono state liberate o problemi di concorrenza (data races). Tutto questo è possibile perché Rust segnala in fase di compilazione eventuali violazioni dei principi sopra esposti, contribuendo in questo modo a mantenere il runtime minimale.
Spostando questi controlli in fase di compilazione non è necessario effettuarli a runtime (il codice compilato è già sicuro), e si possono perciò evitare overhead in fase di runtime. Nel caso della gestione della memoria, questo si traduce nell’inutilità di avere un Garbage Collector a runtime. Tutto questo — avanzato costrutto del linguaggio con pochi o nessun overhead in fase di runtime — è alla base del concetto di “nessuna astrazione”.

Sebbene un’approfondita trattazione del modello di proprietà di Rust esuli dagli obiettivi di questo articolo introduttivo, esistono molte ottime risorse, come il Rust book e articoli che trattano approfonditamente questo argomento. I principi del modello di proprietà e dello strumento di controllo dei prestiti sono due passaggi essenziali per la comprensione di Rust e sono la chiave per comprendere altri aspetti importanti del linguaggio, come la gestione della concorrenza e il parallelismo.

Due piccioni con una fava

La condivisione di stati modificabili è l’origine di tutti i mali. La maggior parte dei linguaggi di programmazione tenta di risolvere questo problema agendo sulla modificabilità, Rust invece agisce sulla condivisione.

citazione da Rust Book

Oltre alla gestione sicura della memoria, il parallelismo e la concorrenza rappresentano il secondo paradigma della filosofia di Rust. Può sembrare sorprendente, ma il sistema di proprietà (assieme all’utilizzo di semplici trait) fornisce anche strumenti potenti per il threading, la sincronizzazione e l’accesso simultaneo ai dati.

Iniziando a utilizzare alcune delle primitive integrate per la gestione della concorrenza e approfondendo la conoscenza del linguaggio, potrebbe risultare sorprendente che tali primitive siano fornite dalla libreria standard piuttosto che direttamente dal core del linguaggio stesso. In definitiva, la creazione di nuove metodologie per la programmazione concorrente è lasciata nelle mani degli autori di librerie piuttosto che essere integrata nel core del linguaggio stesso e e suscettibile alle modifiche pianificate per le versioni future del linguaggio.

Prestazioni o leggibilità del codice? Scegli entrambe

Grazie al sistema di tipizzazione statica, caratteristiche scelte con cura, e l’assenza di un Garbage Collector, i binari ottenuti utilizzando il compilatore Rust sono molto veloci e assolutamente prevedibili, al pari di quelli ottenuti utilizzando linguaggi di basso livello tradizionali come C e C++.

Spostando i vari controlli dall’ambiente di runtime ed escludendo la necessità di un Garbage Collector, il codice risultante imita le caratteristiche prestazionali di altri linguaggi di basso livello, anche se il linguaggio continua a rimanere molto più comprensibile. Gli, apparenti, costrutti di alto livello (stringhe, collezioni, funzioni di ordine superiore, ecc.) eliminano quasi completamente i problemi a runtime che di solito si incontrano con gli stessi costrutti in altri linguaggi. Poiché l’output di un programma Rust dopo la compilazione è in una rappresentazione intermedia LVM, il codice macchina finale trarrà vantaggio di tutti i benefici offerti dal compilatore, multipiattaforma, LLVM e di tutte le ottimizzazioni, presenti e future, apportate al compilatore LLVM.

Si potrebbe continuare per ore sottolineando che con Rust non è necessario preoccuparsi di chiudere un socket o di liberare la memoria, spiegando come l’utilizzo dei trait e delle macro garantiscano una grande flessibilità per l’overload degli operatori, oppure descrivendo gli aspetti della programmazione funzionale in Rust (juggling iterator, closure, funzioni di ordine superiore). Ma inutile prolungare troppo questa trattazione. Prima o poi ci si imbatterà comunque in questi aspetti del linguaggio — e si sa che è più divertente scoprire da sé quanto profonda sia la tana del coniglio.

Piuttosto, iniziamo adesso a concentrarci su del vero codice.

Il primo programma in Rust

Senza ulteriori divagazioni, ecco il primo frammento di codice in Rust:

fn main() {
    println!("Hello, Rust!");
}

Apri questo codice Rust nel playpen online»

Tutto qui? Non è molto scenografico, ma c’è un limite al numero di modi possibili per scrivere un programma “Hello World” in Rust. Di seguito viene mostrato un altro esempio classico spesso utilizzato nei corsi di programmazione.

Giochiamo a Fizzbuzz con Rust

Prendiamo in esame un programma della “vecchia scuola”. Fizzbuzz è un gioco, utilizzato nei paesi anglosassoni per insegnare ai bimbi a contare e a fare le divisioni. Lo scopo del gioco (e dell’algoritmo che andremo a implementare) è quello di contare, teoricamente all’infinito, sostituendo con fizz i numeri che sono divisibili per 3, con buzz i numeri divisibili per 5 e con fizzbuzz i numeri divisibili sia per 3 che per 5 (cioè quelli divisibili per 15).

Per evidenziare meglio la semantica e gli aspetti peculiari di Rust, che sono lo scopo di questo articolo, includiamo i sorgenti dell’algoritmo anche in C e Python.

Versione in C dell’algoritmo Fizzbuzz

#include <stdio.h>

int main(void)
{
    int num;
    for(num=1; num<101; ++num)
    {
        if( num%3 == 0 && num%5 == 0 ) {
            printf("fizzbuzz\n");
        } else if( num%3 == 0) {
            printf("fizz\n");
        } else if( num%5 == 0) {
            printf("buzz\n");
        } else {
            printf("%d\n",num);
        }
    }

    return 0;
}

Versione in Python di Fizzbuzz

for num in xrange(1,101):
    if num%3 == 0 and num%5 == 0:
        print "fizzbuzz"
    elif num%3 == 0:
        print "fizz"
    elif num%5 == 0:
        print "buzz"
    else:
        print num

Versione in Rust di Fizzbuzz

fn main() {
    for num in 1..101 { // Range notation!
        match (num%3, num%5) { // Pattern Matching FTW!
            (0, 0) => println!("fizzbuzz"),
            (0, _) => println!("fizz"),
            (_, 0) => println!("buzz"),
                 _ => println!("{}", num)
        }
    }
}

Apri questo codice Rust nel playpen online»

Anche da queste poche righe di codice si può già iniziare a intravedere i punti di forza di Rust. La differenza più evidente è la scelta di utilizzare il pattern matching, anziché ricorrere alla tradizionale istruzione if. Avremo anche potuto farlo, ma l’utilizzo del metodo match è un importante strumento nel bagaglio di un esperto Rustacean.

L’altra cosa da notare è la notazione mediante l’uso di intervalli del ciclo for, come avviene in Python. Non avremmo però potuto utilizzare, in quanto non previsto dalla filosofia di Rust, un ciclo for classico come nel linguaggio C. I tradizionali cicli for sono considerati fonte di errori e sono perciò stati sostituiti dal concetto più generale di iterazione.

Ora analizziamo più in dettaglio cosa accade nella fase di pattern matching del nostro esempio:

// per il pattern matching creiamo una tupla che contenga
// i resti della divisione intera per 3 e 5
match (num%3, num%5) {
    // quando num è divisibile sia per 3 che 5
    // (entrambi i resti sono 0)
    // -> stampiamo  "fizzbuzz"
    (0, 0) => println!("fizzbuzz"),

    // quando num è divisibile per 3 (il resto è 0)
    // è divisibile per 5? A noi non interessa
    // -> stampiamo "fizz"
    (0, _) => println!("fizz"),

    // quando num è divisibile per 5 (il resto è 0)
    // è divisibile per 3? A noi non interessa
    // -> stampiamo "buzz"
    (_, 0) => println!("buzz"),

    // In qualsiasi altro caso stampiamo il numero
    // Nota, il matching deve essere esaustivo, vale a dire:
    // bisogna considerare tutti i possibili valori, ma questo è forzato
    // dal compiler Rust
         _ => pintln!("{}", num)
}

Questo non è il luogo per trattare approfonditamente il funzionamento del pattern matching, della destrutturazione e per spiegare cosa sono le tuple. È possibile trovare ottimi articoli che trattano questi argomenti in modo approfondito nel libro Rust Book, nel Rust Blog o su Rust By Example, ma pensiamo che accennarli sia un modo per dimostrare le caratteristiche che rendono Rust così potente ed efficace.

Fizzbuzz utilizzando la programmazione funzionale

Per estendere l’ultimo esempio prodotto e per dimostrare la reale versatilità di Rust, nel nostro secondo esempio faremo fare un salto di qualità al codice del nostro Fizzbuzz. Rust definisce se stesso “pluriparadigma”. Possiamo mettere tutto ciò alla prova riscrivendo il programma Fizzbuzz utilizzando la programmazione funzionale. Per avere una migliore prospettiva, mostreremo anche il codice utilizzando le specifiche della versione 6 di JavaScript (EcmaScript 6).

Fizzbuzz, versione JavaScript utilizzando le tecniche della programmazione funzionale della versione 6

Array.from(Array(100).keys()).slice(1)
    .map((num) => {
        if (num%3 === 0 && num%5 === 0) {
            return "fizzbuzz";
        } else if (num%3 === 0) {
            return "fizz";
        } else if (num%5 === 0) {
            return "buzz";
        } else {
            return num;
        }
    })
    .map(output => console.log(output));

Fizzbuzz, versione in Rust utilizzando le tecniche della programmazione funzionale

fn main() {
    (1..101)
        .map(|num| {
            match (num%3, num%5) { // Pattern Matching FTW!
                (0, 0) => "fizzbuzz".to_string(),
                (0, _) => "fizz".to_string(),
                (_, 0) => "buzz".to_string(),
                     _ => format!("{}", num)
            }
        })
        .map(|output| { println!("{}", output); output })
        .collect::<Vec<_>>();
}

Apri questo codice Rust nel playpen online»

Non solo è possibile imitare lo stile di programmazione funzionale di JavaScript mediante l’utilizzo delle closure e le chiamate funzionali ai metodi, ma grazie al potente pattern matching di Rust, è altresì possibile migliorare l’espressività di JavaScript.

Nota: gli iteratori di Rust sono lazy e si rende perciò necessario, per il corretto funzionamento del codice, utilizzare una chiamata al metodo .collect() (che viene denominato un metodo consumer) — dimenticando questa accortezza il codice non funzionerà. Fare riferimento alla sezione consumers del libro Rust Book per ulteriori informazioni su questo argomento.

Scegliere un progetto

A questo punto si dovrebbe essere ansiosi di immergersi in Rust e di iniziare un progetto interessante. Ma che cosa creare? È possibile iniziare sviluppando una piccola applicazione o una piccola libreria e caricarla su crates.io. Molti programmatori hanno già realizzato degli interessanti progetti in Rust: dai piccoli progetti kernel di tipo *nix, a progetti basati su hardware embedded, dai giochi alle strutture lato server, dimostrando che l’unico limite è la propria immaginazione.

Se si vuole iniziare da qualcosa di piccolo, ma collaborando a qualcosa di utile mentre si imparano le parti più complesse della programmazione in Rust, è possibile considerare di collaborare a qualcuno dei progetti presenti su Github o al codice del compiler Rust (anch’esso scritto in Rust).
Oppure, è possibile riscrivere piccole parti delle proprie applicazioni utilizzate nel proprio ambiente produttivo e sperimentare con Rust analizzando i risultati ottenuti. L’interfaccia di Rust per le funzioni esterne, Foreign Function Interface (FFI) è stata realizzata specificatamente per rimpiazzare il codice C. Con un piccolo sforzo è possibile sostituire porzioni di codice dei propri applicativi con del codice Rust. Ma l’interoperabilità non si ferma qui — questi binding per il linguaggio C funzionano anche in modo inverso. Ciò significa che è possibile utilizzare librerie C nel proprio codice Rust — oppure (poiché molti linguaggi di programmazione prevedono un’interfaccia per le librerie standard del linguaggio C) utilizzare chiamate, da e verso, fra Rust e Python, Ruby, o anche Go.

A questo proposito, si guardi il talk di Dan Callahan My Python’s a little Rust-y per imparare a connettere Rust con Python.

Praticamente non esistono linguaggi che non siano in grado di funzionare assieme a Rust. Si desidera compilare il codice Rust in un sorgente JavaScript o utilizzare codice assembly inline nel proprio codice Rust? Si può fare!

E adesso puoi smettere di leggere questo articolo e darti da fare per costruire qualcosa di importante.

E non dimenticare — Rust non è semplicemente un linguaggio di programmazione — è anche una comunità. In caso di problemi è possibile chiedere aiuto nei Forum o su IRC. È anche possibile condividere le proprie impressioni e i propri progetti sul canale Rust Reddit.

Rust è già straordinario — persone come te lo renderanno ancora più grandioso!


Imparare a sviluppare per Firefox OS: la guida veloce

Firefox OS è il progetto Mozilla nato per portare il Web in tutte le tasche grazie al suo essere veloce, semplice e intuitivo. Durante lo scorso anno sono stati organizzati diversi eventi in Italia dedicati al nuovo sistema operativo, anche senza la nostra partecipazione diretta, dimostrandoci che c’è un reale interesse per un qualcosa che non sia il solito iOS o Android. Si tratta di una reale alternativa open source a questi sistemi basata su nuove tecnologie sempre fruibili come HTML5.

Uno dei progetti della nostra community dedicato a Firefox OS è finalmente a disposizione del grande pubblico: la traduzione della Guida veloce allo sviluppo per Firefox OS.

firefoxos-dev-quickguide

Scritto originariamente da Andre Alves Garzia in portoghese e inglese, è stato completamente tradotto da alcuni membri della nostra comunità. Alla localizzazione sono stati aggiunti nuovi materiali e le ultime novità che la guida originale -per ovvi motivi- non contiene. Il lavoro ha richiesto un anno di revisioni e di valutazioni ma ha portato a un risultato indubbiamente valido per qualsiasi sviluppatore HTML, CSS e JavaScript che voglia sperimentare Firefox OS. Durante questo processo abbiamo cercato di rendere il documento semplice e intuitivo come il sistema che intende descrivere e rendere accessibile a tutti.

Questo un estratto completo del nuovo materiale incluso:

  • Linee guida per il Marketplace dove è possibile pubblicare la propria app.
  • Informazioni sul manifest, vera e propria carta d’identità di ogni app.
  • Capitolo sul Boilerplate e su l10n.js per lavorare al meglio.
  • Elenco delle webActivity per capire immediatamente le potenzialità del sistema.
  • Web Component, Moz Polyfill, Firefox Developer Edition sono solo alcune delle tecnologie spiegate.
  • Come sfruttare al meglio le pagine su Github.
  • I nuovi strumenti per gli sviluppatori come il WebIDE.
  • Come usare un telefono Firefox OS per il debug con Firefox.

Tutto il materiale è revisionato e aggiornato all’anno corrente.

Per maggiori informazioni potrete fare riferimento alla pagina su Leanpub in cui scaricare gratuitamente questo ebook nei diversi formati disponibili.

Per lasciare commenti e opinioni potete trovarci e contattarci su GitHub, dove potrete inoltre contribuire attivamente al progetto. È anche possibile partecipare alla discussione nel nostro forum all’interno della discussione dedicata al progetto.

Vorrei personalmente ringraziare tutti i volontari che mi hanno permesso, dopo oltre un anno di lavoro, di arrivare alla pubblicazione di questa versione beta: GiammyJet, Michro, Sara_t, Miki64, Gialloporpora, Edoput e Nicokant. Senza di loro non sarei mai riuscito a portare avanti questo lavoro che spero permetterà di promuovere sempre più questo sistema.

Non dimenticate però che il Mozilla Developer Network è e rimane il riferimento per lo sviluppo di Firefox OS e che questa guida è pensata per coloro che decideranno di provare a sviluppare la propria idea senza perdersi nella moltitudine di pagine pubblicate, una sorta di primi passi verso una più ampia conoscenza del prodotto.

Prima di concludere vorrei invitare tutti a incontrare alcuni dei volontari durante il meetup al CodeMotion del prossimo 27 Marzo dove potrete porre le vostre domande e scoprire i nostri progetti come community, oltre ad accaparrarvi qualche gadget che cerchiamo di non far mancare mai! :-)

Testo di Daniele Scasciafratte, revisione di Giovanni Francesco Solone


APC Paper: Firefox OS sul tuo televisore

Prendete Firefox OS, portatelo fuori da quello che pensate possa essere “l’involucro” più comune in cui racchiuderlo in questo periodo (uno dei cellulari di lancio, quindi) e fatelo girare su una scheda contenuta in quello che chiunque considererebbe un normale libro. Lo ha fatto APC e lo ha chiamato Paper.

VIA ARM Cortex-A9 da 800Mhz, un banco di RAM DDR3 da 512MB con 4GB di NAND Flash dove poter conservare i dati (applicazioni, impostazioni, ecc.), un piccolo chip grafico 2D/3D per permettere di trasmettere sul monitor l’immagine a 720p tramite l’uscita HDMI. Due porte USB 2.0, una microUSB, un’uscita Audio con normale jack tipico da cuffie e un ingresso microfono. Completano il quadro la porta di rete ethernet 10/100 e la possibilità di ospitare una microSD tramite lo slot che trovate vicino alle porte appena descritte.

APC Paper (Firefox OS)

Tutto questo in un piccolo oggetto leggerissimo per una dimensione totale di 204 x 98 x 28mm (W x H x D), completamente realizzato in alluminio e cartone riciclato pressato, che a fare i “green” ci si guadagna sempre 😉

Tutto questo ha un costo: 99 dollari, ordinabile direttamente dal sito web di APC, in linea con la politica prezzi applicata da Mozilla che prevede prodotti estremamente accessibili per tutti.

Oltre le semplici caratteristiche

Sono belle parole, me ne rendo conto, probabilmente vorrete parlare di prestazioni ed esperienza d’utilizzo, eppure lo avete già visto almeno una volta (mi auguro). Su simulatore, su telefono, Firefox OS con i suoi pro e i suoi contro e con la sua voglia di crescere sempre più ha fatto breccia nel cuore di molti e raccolto di contro tantissime critiche costruttive e non, eppure eccoci qui, ancora a parlare del nuovo sistema che -vorrei ricordarvi- pecca di gioventù come qualsiasi altro sistema sviluppato per il mobile. Io, utilizzatore iOS ancora oggi (nonostante possieda anche un Keon con Firefox OS a bordo), ricordo ancora la mancanza del copia-incolla, del multi-tasking o dei mille problemi su quel primo “2G” che si poteva acquistare solo in America. Nessuno “nasce imparato” 😉

Lo stesso accade sull’OS di Mozilla e il Paper APC non fa certo eccezione.

APC Paper (Firefox OS) APC Paper (Firefox OS) APC Paper (Firefox OS)

Cosa vuol dire? Beh è abbastanza scontato, per lo meno per chi ha già avuto modo di mettere le mani sopra alla prima versione rilasciata dell’OS. Ci sono ancora feature non disponibili che lo sono già nelle versioni più recenti, altre limitate, errori che possono essere corretti, alcune delle risorse del sistema che per una limitazione dell’hardware a disposizione vengono ovviamente a mancare (WiFi in primis, non essendoci un chip apposito a bordo, nda).

Un rapido setup (veloce tanto quanto quello sul cellulare o sul simulatore acceso la prima volta), la completa mancanza delle localizzazioni più comuni oltre l’inglese o il francese che si trovano a bordo per poi arrivare alla schermata iniziale dove sarà possibile aggiungere applicazioni e collegamenti.

APC Paper (Firefox OS) APC Paper (Firefox OS) APC Paper (Firefox OS)

Difficile e forse “strano” (nonostante basti farci l’abitudine) il controllo del sistema a video: dovrete collegare un mouse ad una delle porte USB disponibili e spostarvi come se quello fosse il vostro dito, vale quindi per l’apertura delle applicazioni così come per la navigazione tra le schermate. Tenere premuto il pulsante e portare il puntatore dal basso verso l’alto vi permetterà invece di tornare alla schermata iniziale. Forse per una questione meramente estetica l’immagine a monitor è stata tagliata per nascondere (almeno parzialmente) la barra superiore con l’orario, la carica della batteria e gli altri dettagli, basterà comunque portare la finestra verso il basso per richiamare la classica area di notifica del sistema.

APC Paper (Firefox OS)

APC Paper (Firefox OS) APC Paper (Firefox OS) APC Paper (Firefox OS)
APC Paper (Firefox OS) APC Paper (Firefox OS) APC Paper (Firefox OS)

Ho provato a cercare aggiornamenti ma -neanche a dirlo- nessuno disponibile. Ciò che mi auguro è che sul sito del produttore (APC, non Mozilla, nda) possano comparire documentazioni e download per permettere all’utilizzatore finale di aggiornare quel sistema altresì parecchio limitato su un pezzo di ferro che altrimenti sarebbe inutilizzabile per chi non ha la minima esperienza e non sa da dove cominciare a mettere le mani per poterlo far operare diversamente.

Se l’OS è giovane, questo progetto e relativo prodotto lo sono ancora di più, diamo tempo al tempo, non credo -almeno attualmente- che sia il caso di fare un investimento per portare sul televisore di casa propria qualche applicazione sociale o altre già presenti nel Marketplace probabilmente già prodotte e rese disponibili per un qualsiasi SmartTV di generazione più o meno recente.

Sarà per la prossima volta?


Keon con Firefox OS: aggiornamento del sistema

Probabilmente alcuni di voi hanno approfittato qualche tempo fa dell’offerta disponibile su eBay per l’acquisto di un dispositivo ZTE con Firefox OS a bordo, tanti di voi stanno invece aspettando qualcosa di più ufficiale, magari quell’espandersi del mercato del sistema operativo di Mozilla per i dispositivi mobili anche in Italia. A prescindere dalle informazioni che girano sul web, l’argomento di oggi vuole in qualche modo iniziare ad introdurvi a questo mondo con un primo articolo semplice che spiega un’operazione banale ma molto importante: l’aggiornamento del firmware.

Il mio articolo si basa su un Keon della Geeksphone ma l’operazione rimane grosso modo simile anche per gli altri dispositivi dato che al momento non esiste l’aggiornamento OTA (Over the Air) come per iOS o Android. Tutto ciò che vi servirà è un PC con a bordo un sistema operativo a vostra scelta (Linux, Windows o OS X) e il cavo USB generalmente fornito all’interno della scatola del prodotto. Io ho usato una macchina virtuale Windows 7 montata sul mio OS X solo per una questione di semplicità e maggiore diffusione del sistema operativo di Microsoft.

Aggiornare il firmware della casa vuol dire ottenere un’immagine di sistema più recente ed in lingua italiana, un lavoro che Mozilla Italia si sta impegnando a realizzare e portare avanti per tutti i nostri connazionali che avranno modo di mettere mano su un telefono con a bordo Firefox OS.

Sul sito web del produttore è possibile tipicamente trovare driver e documentazione ad-hoc, nel caso di Keon vi basterà seguire una semplice procedura che consiste in:

  • prima di fare qualunque altra mossa occorrerà abilitare sul telefono il “Remote Debugging“. Trovate lo switch seguendo il percorso: Settings, Device Information, More Information, Developer,questo perché al primo avvio di un telefono in Developer Preview non avrete l’italiano come lingua a bordo;
  • collegare il telefono al PC e scaricare nel frattempo i driver relativi al proprio telefono. Nel caso di Keon o Peak (funzionano allo stesso modo) sono disponibili all’indirizzo downloads.geeksphone.com/drivers/usb_driver.zip e dovranno essere utilizzati perché sia Windows 7 che Windows 8 potrebbero non riconoscere l’hardware connesso o installarlo come generico dispositivo Android. Andrà quindi aggiornato il driver proposto con quello contenuto in archivio;
  • a questo punto si potrà scompattare l’archivio dell’aggiornamento di sistema precedentemente scaricato, all’interno del quale troverete i file necessari e gli script da lanciare a seconda del sistema operativo che monta il vostro PC;
  • dato che tutta l’operazione è stata affrontata con Windows è bastato lanciare lo script batch “flash.bat” e seguire le istruzioni a video. Si tratterà di rispondere solo ed esclusivamente a una domanda: è possibile formattare e perdere completamente le impostazioni del telefono? Dato che sto testando queste prime release di sistema che rischiano di essere non del tutto stabili, preferisco avere un telefono sempre pulito, quindi scelgo di formattare completamente il dispositivo perdendo ogni contenuto, che andrà poi reinstallato o re-sincronizzato al successivo avvio del telefono. Basterà lasciar lavorare lo script e attendere che termini, quindi premere un pulsante qualsiasi per riavviare il telefono e chiudere lo script.

Il telefono, una volta riavviato, mostrerà ovviamente la schermata di prima configurazione. Potrete così notare la presenza della lingua italiana (con tanto di tastiera ad-hoc), il giusto fuso orario impostabile e molto altro ancora.

Sappiate che

  • Se il telefono dovesse bloccarsi durante l’aggiornamento basterà avviarlo tenendo premuto il tasto di accensione e quello per aumentare il volume (si trova sul lato sinistro del Keon), si aprirà una schermata di testo e sarà possibile ripetere il flash della ROM;
  • se dopo l’aggiornamento il telefono rimane bloccato sulla schermata nera all’avvio, eseguire il punto 2 (quindi collegare nuovamente il telefono al PC, lanciando il file batch) e scegliere di non mantenere i dati.

Buon aggiornamento :-)


Firefox Flicks Contest: intervista al team Mirabilia

Flicks_logo_500px-BLACK-gioxx.orgIl 12 settembre si è conclusa l’edizione 2013 di Firefox Flicks Contest, il concorso video internazionale organizzato ogni anno da Mozilla per dare spazio ai cineasti esordienti.

Tra le centinaia di video provenienti da ogni parte del mondo, un gruppo italiano è riuscito ad aggiudicarsi il Premio del pubblico, accattivandosi 767 voti degli spettatori con The right way…, una divertente animazione di 60 secondi che insegna un utilizzo più consapevole del Web attraverso le avventure di un naufrago social network-dipendente.

Sara e Sandro hanno intervistato Giuseppe Gallo e Angela Catalano della web agency Mirabilia, creatori del video vincitore, che ci hanno parlato della loro esperienza.

Presentatevi brevemente.
Chi siete e cosa fate nella vita?

Facciamo entrambi parte di Mirabilia, una Web Agency di Palermo, Giuseppe, da poco laureato in ingegneria, è uno dei fondatori del gruppo e si occupa di design della comunicazione, Angela è un’animatrice digitale, entrata nel gruppo in seguito ad uno stage fatto dopo aver conseguito una laurea in Audio/Video e Multimedia presso l’Accademia di Belle Arti di Palermo.

Come vi siete avvicinati al concorso Firefox Flicks? Seguite le iniziative Mozilla, siete interessati al mondo della tecnologia oppure vi ha ispirato l’amore per il cinema?

Firefox è un punto di riferimento per tutti quelli che si occupano di web, normalmente sono i nostri sviluppatori a seguire tutti gli aggiornamenti sulle attività della Mozilla Foundation, questa volta però è stata Angela a parlarci di Firefox Flicks, il nostro gruppo non si era mai occupato di video in precedenza, è stata lei a spingerci a partecipare al concorso, quindi possiamo dire che c’entrano sia l’interesse al mondo della tecnologia e all’attività di Mozilla, sia l’amore per il cinema ed in particolare per l’animazione.

Quando avete candidato il video, quali erano le vostre aspettative? Puntavate già a un premio oppure avete partecipato soltanto per fare un’esperienza nuova? E come vi sentite ad essere gli unici italiani vincitori?

Partecipare ad un concorso è sempre un’attività stimolante, questa volta ancora di più, innanzitutto perché si trattava per alcuni di noi di una sfida totalmente nuova e poi per la tematica trattata, che ci sta davvero a cuore. Proprio perché si trattava di una prima “avventura” insieme, ciò che ci interessava era fare esperienza, siamo partiti dall’idea, dal messaggio che volevamo comunicare, e poi abbiamo pensato ad una storia adatta a trasmetterlo, in seguito Angela ha gestito tutte le fasi di animazione, montaggio video e audio, Giuseppe ha invece realizzato gran parte dei disegni, si è occupato della colorazione e dello stile grafico del video. All’inizio non avevamo grandi aspettative, la scadenza del concorso era vicina (il video è stato realizzato in due settimane) e non eravamo sicuri del risultato finale, e tuttora pensiamo che con un po’ di tempo in più saremmo riusciti a migliorarlo. Immaginate la nostra sorpresa e la felicità quando abbiamo scoperto di aver vinto un premio del pubblico, per un concorso tanto importante a cui hanno partecipato più di 400 concorrenti. È un onore rappresentare in qualche modo il nostro paese, tra i flicks partecipanti c’erano altri Italiani e alcuni erano davvero molto belli!

Parlateci dello sviluppo del video: come è nata l’idea? Perché avete scelto l’animazione e non il live action? Qual è stato l’aspetto più difficile e quale quello più divertente?

L’idea del video nasce dall’attività svolta tutti i giorni all’interno dell’agenzia. Il tema del Firefox Flicks di quest’anno era il mobile, noi siamo andati un po’ oltre, parlando dell’utilizzo che facciamo dei nostri dispositivi mobili. La prima volta che abbiamo pensato al video, immaginavamo un live action, sarebbe stato fantastico realizzare delle riprese per raccontare la nostra storia, solo che il tempo stringeva, abbiamo quindi scelto di puntare più sulla struttura del racconto e sull’esperienza di Angela nell’animazione.

Ci siamo subito messi al lavoro, abbiamo immaginato un’isola, un ambiente caratteristico ed eccezionale pieno di strane piante, un personaggio buffo, “utonto” inconsapevole del web mobile. Altro aspetto molto importante del video è la narrazione tramite social network, questi fanno parte della nostra vita, li utilizziamo per raccontare le nostre vite, ci condizionano e crediamo che tramite questi si possano sperimentare nuove forme di storytelling.

Riguardo al tema del video, sembra prendere bonariamente in giro l'”utente medio” dello smartphone, che sta sempre attaccato ai social network ma si dimentica delle funzioni del dispositivo che potrebbero migliorare la sua vita (o salvargliela, nel caso del protagonista del video!). Volete parlarci più approfonditamente del messaggio che trasmette il vostro flick?

Il largo utilizzo dello smartphone è probabilmente la rivoluzione tecnologica più importante degli ultimi anni, hanno cambiato radicalmente le nostre abitudini, siamo in grado di raggiungere informazioni di ogni genere istantaneamente, la nostra vita è diventata più veloce, sotto tanti aspetti più facile, ma non per forza migliore. Come ogni nuova tecnologia il web mobile sta vivendo un boom, ed è destinato a crescere, adesso, non siamo i soli a pensarlo, è il momento di farne un uso più consapevole.

Per trasmettere in modo più efficace questo messaggio, abbiamo riflettuto sugli utilizzi più banali dello smartphone e quando il nostro “utonto” si ritrova su un’isola deserta, in una situazione estrema, trovando un telefono che magicamente funziona, invece di pensare immediatamente alla sua salvezza, facendo un utilizzo intelligente dello strumento che ha trovato, ricade nell’abitudine, inizia a condividere foto dell’isola, di ciò che sta mangiando, non pensando a geolocalizzarsi e chiedere aiuto. Quello immaginato nel video è ovviamente un caso estremo, ma ci può aiutare a riflettere, a diventare utilizzatori più consapevoli del web mobile.

Approfittiamo di quest’occasione per ringraziare tutti i nostri amici che ci hanno votato, senza di loro non avremmo vinto :-)

E noi ringraziamo loro per averci concesso questa intervista!