Ieri sera ho ricevuto l’invito a partecipare alla traduzione collaborativa di Twitter (vedi gruppo relativo su Google Groups): incuriosito, ho accettato l’offerta e mi sono iscritto al gruppo di discussione. Questa mattina ho avuto modo di provare il sistema di traduzione, e devo ammettere che si tratta di uno strumento molto interessante:

• il box di traduzione, dove possibile, indica all’interno della pagina la stringa che si sta traducendo (in pratica si tratta di un layer mobile sovrapposto alla pagina);
• vengono visualizzati suggerimenti proponendo la traduzione eseguita da altre persone (ho provato una trentina di stringhe, ma di suggerimenti non ne ho visti);
• è possibile tradurre tutte le stringhe senza lo strumento contestuale (al momento sono 1399).

Detto questo, l’operazione in sé presenta dei grossi limiti:

• ho la sensazione che la scelta degli utenti sia stata fatta senza particolari filtri. Se ci sono 100 potenziali traduttori, e di questi solo 5 hanno esperienze significative di localizzazione, il rischio è quello di avere una traduzione di scarsa qualità e poco uniforme;
• la mancanza di un leader e di regole di stile condivise a priori è un buon metodo per creare un’accozzaglia di stringhe, non un prodotto localizzato a dovere;
• dal punto di vista tecnico: delle “localization note” associate alle stringhe contenenti variabili e parti da non tradurre sarebbe molto più utile del generico avviso che si ottiene quando si inizia la traduzione.

In realtà il problema principale è un altro: perché mai dovrei tradurre gratuitamente un’applicazione web che raccoglie milioni di dollari? Per avere un badge nel mio profilo che mi segnala come traduttore e farmi bello con gli amici? Per vedere nuove funzioni in anteprima (ma di cui non potrò parlare)?

Là fuori ci sono centinaia di progetti Open Source alla costante ricerca di localizzatori per software e documentazione: se avete tempo libero da dedicare alla traduzione, il mio consiglio è quello di utilizzarlo per queste attività, non per tradurre Twitter. Pensate ai prodotti Open Source che utilizzate quotidianamente e provate a dare un’occhiata sui rispettivi siti, difficilmente rifiuteranno un aiuto (per Mozilla Italia ci sono almeno un paio di progetti costantemente aperti e altri in attesa di cure e affetto).

Pregiato amico tuìttero,
mi spieghi gentilmente, con parole lunghe e ben distese, quale arcano bisogno ti spinge a informarmi ogni volta che produci un post sul tuo blog, sul tuo tumblr e forse anche sulla lavagna appesa al frigorifero della tua magione?

A nulla servono le fantasiose etichette che piazzi di fronte al messaggio auto promozionale, giacché la dotazione di tuìtter non comprende la possibilità di filtrare tali etichette.

Dal canto mio, quale esempio di rettitudine e buona volontà, cercherò di utilizzare con parsimonia i messaggi @, ché tuìtter non è ciàt.

Baci.

P.S. nel caso avanzassi tempo, leggi pure questo

Come richiesto espressamente da Maurizio, in questo post vi spiegherò con dovizia di particolari come ho ottenuto l’immagine presente in questo post 😛

L’idea

L’idea di base è semplice: realizzare un’immagine in grado di rappresentare le relazioni che collegano i miei amici (friends) in Twitter e gli “amici degli amici”, in pratica due livelli di twitter-relazioni a partire dal sottoscritto.

Doverosa premessa: non sono un programmatore, queste sono le prime righe che scrivo in Python e non ho mai frequentato i grafi in vita mia 😉

Python

Ecco un elenco dei software indispensabili (nel mio caso il tutto è stato realizzato su Mac Os X):

• Python: l’ultima versione è la 2.5.1, per Mac Os X è disponibile un comodo installer
• Setuptools
• Python Twitter comprensivo di semplici istruzioni di installazione
  

Generazione del file .dot

Per la generazione del file .dot ho scritto qualche riga di codice in Python (è la volta buona che mi costringo ad impararlo…).

#!/usr/bin/python

import twitter, simplejson, time
class ApiEstesa (twitter.Api):
  ''' Estende Api per recuperare i friends di un user diverso dal proprio '''

  def __init__(self):
      twitter.Api.__init__(self)

  def GetAnotherOneFriends(self, username, password, identificativo):
      url = 'http://twitter.com/statuses/friends/'+str(identificativo)+'.json'
      json = self._FetchUrl(url, username=username, password=password)
      data = simplejson.loads(json)
      return [twitter.User.NewFromJsonDict(x) for x in data]

def aggiungi_soggetti (utenti, relazioni, id):
  '''Aggiunge gli id dei friends dell'utente con identificativo ID al dizionario id_soggetti'''

  try:
    friends = api.GetAnotherOneFriends(user, password, id)
  except:
    print 'Errore nel recupero dei dati da Twitter: attendo 10 secondi e riprovo'
    time.sleep(10)
    friends = api.GetAnotherOneFriends(user, password, id)

  for friend in friends:
    utenti.setdefault(friend.id, friend.screen_name)
    relazioni.append('  '+str(id)+' -- '+str(friend.id)+'n')

api = ApiEstesa()

user = 'vostro_user'
password= 'vostra_password'
identificativo = 'vostro_id'
screen_name = 'vostro_nome_visualizzato'

# Recupero i friends del soggetto principale
friends = api.GetFriends(user, password)

# Uso un dizionario per evitare la duplicazione degli utenti; aggiungo subito il soggetto principale
id_utenti = {}
id_utenti.setdefault(identificativo, screen_name)
relazioni = []

for friend in friends:
    # Aggiungo i friends del soggetto principale al dizionario id_utenti
    id_utenti.setdefault(friend.id, friend.screen_name)
    # Aggiungo le relazioni del soggetto principale
    relazioni.append('  '+identificativo+' -- '+str(friend.id)+'n')
    # Aggiungo i friends e le relazioni del friend che sto controllando
    aggiungi_soggetti(id_utenti, relazioni, friend.id)
    print 'Aggiungo soggetto e relazioni di '+friend.screen_name

lista_utenti = id_utenti.items() # Trasformo il dizionario in una lista
inizio_file = '''graph relazioni_twitter {
  graph [bgcolor=black, overlap="scale", ratio="auto"];
  node [fontcolor="white", fontsize="10", shape="circle", color="antiquewhite"];
  edge [color="gold1"];n'''

f = open('grafico_prova.dot','w')

# Scrivo su file la parte iniziale del grafo
f.writelines(inizio_file)

# Scrivo la label del nodo root (soggetto principale)
f.writelines('  %s [label="%s", root="1", fontcolor="red",shape="circle"];n' % (identificativo, screen_name))

# Scrivo su file tutti i soggetti raccolti in lista_utenti
print '%s nodi, %s relazioni' % (str(len(lista_utenti)),str(len(relazioni)))

for utente in lista_utenti:
  f.write('  %s [label="%s"];n' % utente)

f.writelines('n')

for relazione in relazioni:
  f.write(relazione)

f.writelines('}n')
f.close()

Primo problema: per qualche strano motivo il modulo per Twitter non prevede una funzione per leggere i friends di un utente diverso dal proprio, funzionalità prevista dalle API di Twitter. A questo punto è stato necessario estendere la classe originaria con una nuova funzione: getAnotherOneFriends.

Descrizione del codice (qui lo potete scaricare come file di testo):

• creo delle variabili con il mio identificativo, il mio user, la mia password e il mio screen_name (nome visualizzato)
  
• ottengo una lista dei miei friends (friends)
• scorro la lista: ogni friend viene aggiunto al dizionario id_utenti e, tramite la funzione aggiungi_soggetti, aggiungo i suoi friends al dizionario e le relazioni alla lista omonima
• alla fine non resta che scrivere su file l’elenco dei nodi e le relazioni (questo è file .dot generato)

L’algoritmo è volutamente semplice: così come è strutturato, ad esempio, non sarebbe in grado di rilevare delle relazioni di terzo grado senza generare una marea di ripetizioni inutili. Il time.sleep(10) serve ad evitare che un down di Twitter (già verificatosi 3 volte stasera) blocchi completamente la generazione 😉

Appena ho un attimo di tempo conto di ristrutturare il codice in modo da permettere di analizzare le relazioni per n-livelli (anche se in quel caso il problema sarà il grafo…)

Generazione del grafo

Questa è la parte più complicata e, al momento, parzialmente irrisolta. Per Mac Os X esiste un ottimo software che però è vecchio e non più supportato (il che significa, tra le altre cose, che funziona in emulazione con Rosetta sul mio iMac Core 2 Duo). Sullo schermo riuscivo chiaramente a leggere i nomi sui nodi, nell’esportazione in png il file è stato ridimensionato drasticamente rendendo i nomi invisibili. Per generare l’immagine ho comunque utilizzato PixelGlow con l’impostazione Energy Minimized.

Al momento sto provando a ricreare un grafico usando neato e twopi da linea di comando ma incontro qualche problema: segmentation fault ed errori simili, che elimino solo impostando delle dimensioni inferiori per il grafo, peccato solo che rendano i nodi incomprensibili.

In queste ore sto anche provando a generare il grafo sul PowerBook G4 con PixelGlo; stamattina sul P4 3.0Ghz in ufficio (Windows XP) sono arrivato ad occupazioni di memoria di 3GB senza ottenere grandi risultati.

Domande in sospeso

1. Avete suggerimenti per la realizzazione del grafo? Sbaglio qualcosa nella sintassi del file .dot?
2. Python: qualcuno è in grado di spiegarmi perché, pur utilizzando un dizionario e setdefault, mi ritrovo un nodo (quindi una chiave) ripetuto per ben 3 volte? Il nodo incriminato è quello del soggetto principale.

Da sabato scorso sto facendo qualche prova con Python, le API di Twitter e GraphViz: per il momento sono riuscito ad ottenere un’immagine, incomprensibile ma affascinante 😛

L’idea di fondo è semplice: rappresentare i miei amici (friends) e gli amici dei miei amici (amici di 2° grado). Sembrano pochi dati, in realtà siamo già ad un file di testo di 8160 righe.

Ecco il risultato:

L’utente in fondo a destra che genera una raggiera di relazioni è TheMacPack 😉

Cosa? Non sapete cosa sia Tumblr? Ok, leggete questo e poi ripassate dal via.

Ora che tutti sappiamo cos’è Tumblr, vorrei segnalare due modi poco interessanti di usare il proprio tumblelog:

• usarlo solo per segnalare i post che hai inserito sul tuo blog “normale”: se ti conosco e faccio un giro sul tuo tumblelog, è probabile che segua anche il tuo blog. In pratica mi fai leggere due volte la stessa cosa, il che a lungo andare diventa un filo noioso. Ci può stare una volta ogni tanto, non ad ogni singolo post 😉
• usarlo per riproporre quello che scrivi su Twitter: vale lo stesso discorso, se seguo il tuo tumblelog probabilmente sei anche tra i miei friends in Twitter.

Sia chiaro: non ho alcuna intenzione di insegnare ad altri come usare questo strumento, mi limito solo a far notare quello che ritengo un uso improprio (e in alcuni casi fastidioso) del mezzo 😉

Se siete interessati e volete seguire i tumblelog italiani, potete abbonarvi a questo feed (grazie oRi0n).

Oggi faccio un’eccezione e rispondo velocemente (=di fretta) al meme di DelyMyth: perché uso Twitter?

Rispondo non tanto per evitare di fare la figura dell’orso quale sono, quanto per non passare per pigro (quello è jooliaan, che al momento ha perso la sua proverbiale pigrizia e mi sta tartassando via ICQ).

Perché uso Twitter:

• perché mi permette di scrivere in terza persona senza sembrare fuori di testa
• perché mi permette di vedere in tempo reale cosa stanno facendo tutti i miei amichetti asociali, brutti e sfigati

Motivi pseudo-seri:

• perché posso consultarlo via web anche quando sono in ufficio o dal cliente, senza bisogno di fastidiosi login
• perché ha tempi di reazione e aggiornamento molto più rapidi di un blog o del.icio.us
• perché spesso offre spunti interessanti di lettura
• perché offre scampoli di umanità che difficilmente un blog può offrire