Claudio Cherubino's blog Life of a Googler

25Feb/090

I fumetti del futuro

Nasce da un gruppo italiano quello che potrebbe essere il capostipite di un nuovo modo di intendere i fumetti.

Sto parlando di A Separate World, un fumetto multimediale (o enhanced comics, come viene definito dagli autori) da visualizzare su iPhone e che si distacca dai classici fumetti per l'aggiunta di colonna sonora, filmati e alcuni aspetti interattivi.

Il primo numero conterrà 120 pagine e dovrebbe costare 79 centesimi; il rilascio è previsto per metà Marzo.

Per ingannare l'attesa vi lascio con il teaser del fumetto, che ne pensate?

21Feb/090

Sbarco su Twitter

Ho provato a resistere a lungo, ma alla fine ho ceduto ed ho aperto anche io un account su Twitter (ccherubino).

Devo ammettere che il micro-blogging mi attira e si abbina molto più facilmente del blog tradizionale alla mancanza di tempo per scrivere.

Adesso mi trovo a barcamenarmi fra lo studio delle potenzialità di Twitter e la ricerca dei twit più interessanti da seguire, stando però attento a non dedicare troppo tempo a questo nuovo interesse.

Se volete sprecare il vostro tempo, potete seguirmi su http://www.twitter.com/ccherubino oppure dare semplicemente un'occhiata al widget che trovate nella colonna di destra di questo sito.

E ora mi consigliate qualche altro account Twitter da non lasciarmi scappare?

18Feb/090

Perchè Sanremo è Sanremo

Probabilmente è solo colpa dell'età che avanza, fatto sta che sono riuscito a vedere (quasi tutta) la prima puntata del Festival di Sanremo senza annoiarmi.

Pensavo che nemmeno Bonolis sarebbe riuscito a svecchiare questa manifestazione eppure mi devo ricredere: conduzione allegra e tempi più rapidi, tanto che dopo mezz'ora avevano già cantato 3 o 4 concorrenti.

Fra una canzone e l'altra i siparietti di Luca Laurenti, le inutili apparizioni della valletta (e del valletto!) e, soprattutto, il geniale intervento di Benigni che ha saputo miscelare sapientemente satira a discorsi molto più seri, concludendo con una riflessione sull'omosessualità seguita dall'interpretazione di una toccante lettera di Oscar Wilde.

Non so come sia finita la puntata né soprattutto riesco a ricordare qualche canzone, ma per quanto mi riguarda è già uno dei migliori Sanremo che abbia visto! :smile:

12Feb/090

Kindle 2, il nuovo e-book reader di Amazon

Lunedì scorso Jeff Bezos, il fondatore di Amazon, ha radunato stampa e curiosi a New York per presentare il Kindle 2, il nuovo e-book reader successore di quel primo modello che riuscì a vendere poco meno di un milione di copie, anche se quasi tutte negli Stati Uniti.

Io personalmente non ho mai pensato di poter sostituire i libri cartacei con un lettore digitale, però devo ammettere di aver atteso con grande curiosità l'annuncio del nuovo modello.

Il nuovo Kindle sarà sottilissimo (solo 9 millimetri di spessore) e con uno schermo da 6 pollici a 16 toni di grigio con una risoluzione di 600x800.

La memoria interna sarà pari a 2 Gb e la durata della batteria dovrebbe attestarsi sulle due settimane.

Per trasferire i libri dal pc è disponibile una porta USB ma è anche possibile scaricarli tramite una connessione Wi-Fi 3G, che sarà fornita gratuitamente negli Stati Uniti.

Ed è proprio questo l'unico problema per chi come me potrebbe essere interessato al nuovo Kindle ma che non vive in America. Quella fornita infatti non è una normale connessione Wi-Fi bensì si tratta di una rete dati proprietaria come quelle ad esempio di Tim o Vodafone.

Questo comporta che negli Stati Uniti la copertura sarà anche migliore di quella Wi-Fi tradizionale, ma in Europa (e di conseguenza in Italia) la copertura è praticamente nulla e l'unico modo per scaricare i libri sarà tramite un pc.

Probabilmente per colpa di questa mossa Amazon non riuscirà ancora una volta a conquistare l'Europa e il resto del mondo, ma a quanto pare l'azienda non è interessata ad un mercato differente da quello statunitense.

Io fra un paio di mesi sarò a New York, chissà che non ci faccia un pensierino...

Ah, quasi dimenticavo di dirvi il prezzo: 359 dollari, al cambio attuale sono poco meno di 300 euro.

12Feb/092

Brainfuck interpreter in F#

Brainfuck is an esoteric programming language whose grammar consists of only eight commands, written as a single character each.

Besides this minimalistic structure, the language is Turing-complete but writing (and reading) Brainfuck code is very hard.

The Brainfuck machine uses a finite-length tape (usually 30000 byte cells long) and two pointers: an instruction pointer and a data pointer.

The former scans the source code and executes one instruction at a time, while the latter is used to increase or decrease the value of the cell that it is pointing.

This structure can be represented by the following F# type, called BFState:

type BFState =
  { mutable program : string ;        // program being interpreted
    mutable memory : int[] ;          // memory
    mutable pc : int ;                // current program counter
    mutable pos : int }               // current pointer position

We define then a function to initialize our Brainfuck machine given the size of the memory tape and the source code, that basically zeroes all memory cells and the two pointers:

let initState memSize code  =
  { program = code;
    memory = Array.zero_create memSize;
    pc = 0;
    pos = 0; }

We reach the end of the program when the program counter steps beyond the end of the code (i.e. the length of the string containing the source):

let isEnd (state : BFState) =
  state.pc >= state.program.Length

The following two functions are used to move the program counter one step towards the end or the beginning of the source code:

let nextCommand (state : BFState) =
  { program = state.program ; memory = state.memory ; pc = state.pc + 1 ; pos = state.pos }

let previousCommand (state : BFState) =
  { program = state.program ; memory = state.memory ; pc = state.pc - 1 ; pos = state.pos }

getMem and setMem are two auxiliary functions that can be used to retrieve or set the value of the memory cell pointed by the data pointer:

let getMem (state : BFState) =
  state.memory.[state.pos]

let setMem (state : BFState) value =
  state.memory.[state.pos] <- value
  state.memory

Similarly, we have two functions to read and write from the console, which is the behavior of the ',' and '.' commands respectively:

let outputByte (state : BFState) =
  Console.Write (Convert.ToChar(state.memory.[state.pos]))
  nextCommand state

let readByte (state : BFState) =
  state.memory.[state.pos] <- Console.Read()
  nextCommand state

When the command to perform is '[', if the byte at the data pointer is zero we have to jump to the first matching ']' character following the current position:

let rec moveToForwardMatch (state : BFState) =
  match state.program.[state.pc] with
  | ']' -> (nextCommand state)
  | _ -> moveToForwardMatch (nextCommand state)

The complementary command is ']', that goes back to the matching '[' character when the byte at the data pointer is non-zero:

let rec moveToPreviousMatch (state : BFState) =
  match state.program.[state.pc] with
  | '[' -> (nextCommand state)
  | _ -> moveToPreviousMatch (previousCommand state)

We have now all the tools required to parse Brainfuck code, so we only need to write the logic to select the action to perform according to the command analyzed in a single step.

Each command takes a BFState and returns a new BFState. Any character different from the eight allowed will be simply ignored:

let step (state : BFState) =
  match state.program.[state.pc] with
  | '+' -> { program = state.program ; memory = setMem state (getMem state + 1) ; pc = state.pc + 1 ; pos = state.pos }
  | '-' -> { program = state.program ; memory = setMem state (getMem state - 1) ; pc = state.pc + 1 ; pos = state.pos }
  | '<' -> { program = state.program ; memory = state.memory ; pc = state.pc + 1 ; pos = state.pos - 1}
  | '>' -> { program = state.program ; memory = state.memory ; pc = state.pc + 1 ; pos = state.pos + 1}
  | '[' -> if (state.memory.[state.pos] = 0) then moveToForwardMatch state else nextCommand state
  | ']' -> if (state.memory.[state.pos] <> 0) then moveToPreviousMatch state else nextCommand state
  | '.' -> outputByte state
  | ',' -> readByte state
  | _ -> nextCommand state // ignore any non-command character

The parser, which could be the only publicly available function, will take care of initializing the state and recursively step through the code, one instruction at a time, until the end of the source:

let parse memSize code =
  let rec run (state : BFState) =
    if (not (isEnd state)) then
       run (step state)
  initState memSize code |> run

You can find a repository of Brainfuck sample programs at this site: http://esoteric.sange.fi/brainfuck/bf-source/prog/, the following code contains the classic Hello World! and how to parse it using the interpreter we just wrote:

let code = ">+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+."

parse 30000 code

The whole Brainfuck interpreter code can be found just below, feel free to take it and dissect it:

#light
open System

type BFState =
  { mutable program : string ;        // program being interpreted
    mutable memory : int[] ;          // memory
    mutable pc : int ;                // current program counter
    mutable pos : int }               // current pointer position

let initState memSize code  =
  { program = code;
    memory = Array.zero_create memSize;
    pc = 0;
    pos = 0; }

let isEnd (state : BFState) =
  state.pc >= state.program.Length

let nextCommand (state : BFState) =
  { program = state.program ; memory = state.memory ; pc = state.pc + 1 ; pos = state.pos }

let previousCommand (state : BFState) =
  { program = state.program ; memory = state.memory ; pc = state.pc - 1 ; pos = state.pos }

let getMem (state : BFState) =
  state.memory.[state.pos]

let setMem (state : BFState) value =
  state.memory.[state.pos] <- value
  state.memory

let rec moveToForwardMatch (state : BFState) =
  match state.program.[state.pc] with
  | ']' -> (nextCommand state)
  | _ -> moveToForwardMatch (nextCommand state)

let rec moveToPreviousMatch (state : BFState) =
  match state.program.[state.pc] with
  | '[' -> (nextCommand state)
  | _ -> moveToPreviousMatch (previousCommand state)

let outputByte (state : BFState) =
  Console.Write (Convert.ToChar(state.memory.[state.pos]))
  nextCommand state

let readByte (state : BFState) =
  state.memory.[state.pos] <- Console.Read()
  nextCommand state

let step (state : BFState) =
  match state.program.[state.pc] with
  | '+' -> { program = state.program ; memory = setMem state (getMem state + 1) ; pc = state.pc + 1 ; pos = state.pos }
  | '-' -> { program = state.program ; memory = setMem state (getMem state - 1) ; pc = state.pc + 1 ; pos = state.pos }
  | '<' -> { program = state.program ; memory = state.memory ; pc = state.pc + 1 ; pos = state.pos - 1}
  | '>' -> { program = state.program ; memory = state.memory ; pc = state.pc + 1 ; pos = state.pos + 1}
  | '[' -> if (state.memory.[state.pos] = 0) then moveToForwardMatch state else nextCommand state
  | ']' -> if (state.memory.[state.pos] <> 0) then moveToPreviousMatch state else nextCommand state
  | '.' -> outputByte state
  | ',' -> readByte state
  | _ -> nextCommand state // ignore any non-command character

let parse memSize code =
  let rec run (state : BFState) =
    if (not (isEnd state)) then
       run (step state)
  initState memSize code |> run
9Feb/091

I nostri antenati preistorici

Vi siete mai chiesti che aspetto avevano i vostri antenati vissuti qualche milione di anni fa nella Preistoria?.

Per scoprirlo è possibile sfruttare il servizio Devolve Me, ospitato dalla sezione dedicata a Charles Darwin della The Open University.

Il funzionamento è molto semplice, basta uploadare una propria foto e iniziare un viaggio a ritroso nel tempo per vedere se stessi in versione Australopiteco, Homo Habilis, Homo Erectus e Homo Heidelbergensis (detto anche Homo Sapiens arcaico).

Questo sono io tre milioni e mezzo di anni fa. Dite che mi somiglia?

Australopiteco

3Feb/090

Protezionismo e libero mercato

Un'azienda italiana, la Irem, si è aggiudicata una gara di appalto per dei lavori presso una raffineria inglese ma i lavoratori italiani hanno trovato ad attenderli gli scioperi dei colleghi britannici, che hanno bloccato gli impianti chiedendo che i posti vengano assegnati a persone locali.

Immagino che la storia la conosciate tutti, così come la dichiarazione del premier inglese Gordon Brown che definisce gli scioperi "indifendibili" e le reazioni indignate della stampa e dei politici italiani che inneggiano alla libertà del mercato.

Però forse questi nostri politici si sono dimenticati che giusto qualche mese fa noi italiani abbiamo "salvato" Alitalia, accollandoci molti debiti pur di garantire la sua "italianità".

Come dire che vogliamo protezionismo per quanto riguarda le attività italiane e libero mercato per quanto riguarda le aziende estere? Evviva la coerenza...

1Feb/090

Fringe, l’erede di X-Files

Ieri sera ho visto l'episodio pilota di Fringe, la nuova creazione di J.J. Abrams, l'uomo che è anche dietro il successo di Alias e Lost.

La serie mi ha ricordato X-Files e questo non può che essere un bene, considerando quanto ne ero appassionato una decina di anni fa.

Nel primo episodio di Fringe vengono presentati i personaggi principali e questi vengono subito messi alla prova da un caso alquanto inusuale, un aereo che atterra a Boston con tutti i passeggeri e i membri dell'equipaggio morti, infettati da un virus letale sconosciuto.

Ovviamente la cosa è più grossa di quanto sembra, ma solo nei prossimi episodi scopriremo se la verità verrà a galla o resteremo all'oscuro di tutto per anni come accade in Lost! :lol:

La prima stagione della serie è iniziata a Settembre negli Stati Uniti e non è ancora finita, mentre in Italia viene trasmessa a partire da ieri ogni Sabato su Mediaset Premium.

Nessun altro ha visto l'episodio pilota di Fringe?