Simbolo di Tor

Normalmente sul sito di TRL è possibile esprimere un massimo di 3 preferenze, ossia è possibile votare dallo stesso computer per un massimo di 3 volte. Ma come evitare questo controllo e votare infinite volte? Semplice: cambiando indirizzo IP. Per farlo c’è TOR, il noto sistema di proxy che permette agli utenti di nascondere dinamicamente il loro indirizzo IP passando per altri computer ( detto con parole povere )

Ma lo script di Nicola è in PHP!!! Così preso dalla smania, ho realizzato in 10 minuti un’alternativa in python, ma che facesse la stessa cosa, in meno righe e più facilmente… il risultato?

http://www.koalalorenzo.com/source/wintrl.py

In teoria il codice è multi-piattaforma ( Mac, Linux e Windows ) e dovrebbe girare ovunque siano installati Tor e Python, ma non avendo un Mac non ho potuto testare. Se volete vincere TRL, installate sulla vostra macchina TOR ed eseguite lo script con questo comando:

python ./wintrl.py http://extra.mtv.it/trl/vota.asp?idVideo=24871

A meno che non vogliate votare Rock That Body dei Black Eyed Peas, dovrete sostituire l’indirizzo ( http://extra… ) con l’indirizzo della pagina che visitate per votare quel video. Lo script automaticamente riconoscerà il codice del video e lo voterà. Per chi invece già conoscesse il codice potrà comunque utilizzare lo script con questo comando:

python ./wintrl.py 24871

Basterà sostituire 24871 con il codice del vostro video. il mio script inizierà a votare infinite volte il vostro video. Facile vero?

Ora mi chiedo, ma i webmaster pagati da MTV non han ancora provveduto a risolvere questo banale problema? :S Nicola propone un “3+3″ io propongo l’autenticazione mediante social network (es: Facebook) così da inquadrare meglio la situazione e gli spettatori

Lo script non sfrutta alcuna falla, ma semplicemente la mancanza di un controllo ( Login o Captcha ) da parte del sistema di votazione. Il funzionamento è applicabile anche a qualsiasi altro sistema privo di controllo grafico che accerti che a votare sia una persona fisica e non un computer.

Tornado Web Server

Per grazia divina, i creatori di FriendFeed han realizzato Tornado. Questo Web Server Open Source fa al caso nostro: Tornado è alla base di Friendfeed ma può essere sfruttato per realizzare qualsiasi altro genere  disito web. Ma a noi interessa creare un Social Network non un semplice blog! Con Tornado possiamo farlo!

Prima di tutto è necessario installare Tornado sulla nostra macchina. Quindi apriamo un terminale e digitiamo i seguenti comandi:

sudo apt-get install python-simplejson python-pycurl
wget http://www.tornadoweb.org/static/tornado-0.2.tar.gz
tar xvzf tornado-0.2.tar.gz
cd tornado-0.2
python setup.py build
sudo python setup.py install

A questo punto tutte le librerie python sono state installate nel sistema e sono pronte per essere utilizzate! Ora passiamo alla parte fondamentale: Cosa deve fare il nostro motore? Cosa l’utente deve essere in grado di fare con il nostro servizio? Il nostro social network come deve essere costituito? L’utente dovrà:

• Autenticarsi, registrarsi ed uscire dal social network. ( Login & Logout)
• Scrivere messaggi.
• Rispondere ai messaggi

Queste sono le funzionalità minimali e per realizzarle dovremo prima vedere come è strutturato Tornado. Per chi avesse voglia di leggere la documentazione ufficiale in inglese è possibile farlo direttamente dal sito.

Iniziamo: Mettiamo le mani nel cuore del nostro motore creando il file server.py che dovrà essere eseguito per avviare il nostro Social Network. Per prima cosa modifichiamolo inserendo le prime righe:

#!/usr/bin/env python
# -*- coding=utf-8 -*-
import os, sys, re
from sqlite3 import dbapi2 as sqlite
import tornado.auth
import tornado.httpserver
import tornado.ioloop
import tornado.options
import tornado.web
import hashlib
import time
from tornado.options import define, option

Questa parte del codice importa le librerie necessarie per il nostro motore: oltre a tornado Tornado, importerà anche hashlib, time e sqlite in modo da poter utilizzare i database, il tempo e la libreria per calcolare gli hash di alcuni valori (come le password). Adesso impostiamo la porta dove il nostro Web Server dovrà lavorare. Aggiungiamo la seguente riga:

define("port", default=80, help="run on the given port", type=int)

A questo punto non ci resta che scrivere il codice vero e proprio del nostro motore: dovremo scrivere una applicazione tornado, che sotto forma di classe gestirà il social network. È importante far notare che questa classe associa dei gestori ( Handler ) a determinati indirizzi. Questi Handler non sono altro che classi che analizzano le richieste e rielaborano le pagine. Inseriamo nel file server.py il seguente codice:

class Application(tornado.web.Application):
    def __init__(self):
        handlers = [
            (r"/", HomePageHandler),
            (r"/auth/login", LogInHandler),
            (r"/auth/logout", LogOutHandler),
            (r"/auth/join", JoinHandler),
            (r"/write", NewPostHandler),
            (r"/([^/]+)", ReadHandler),
            ]
        settings = dict(
            base_address="http://127.0.0.1/",
            social_name="MySocialNetwork",
            template_path=os.path.join(os.path.dirname(__file__), "templates"),
            static_path=os.path.join(os.path.dirname(__file__), "static"),
            cookie_secret="itsasecret",
            login_url="/auth/login",
        )
        tornado.web.Application.__init__(self, handlers, **settings)

        self.database = sqlite.connect("database.sql")
        self.cursor =  self.database.cursor()

Questa classe imposta i vari Handler per i vari indirizzi utilizzabili, e setta anche il Database sqlite da utilizzare per salvare i dati del nostro social network. Ho preferito utilizzare Sqlite a MySql per motivi pratici. Nel dizionario delle impostazioni dell’applicazione ho definito alcuni valori importanti, come l’indirizzo da utilizzare, la cartella dei file statici e quella dei templates, il nome del social network, una chiave segreta per i cookies e l’indirozzo per l’autenticazione richiesto da Tornado.  Non ci resta che scrivere le classi degli Handler. Come  nella documentazione di Tornado, BaseHandler ci permette di risparmiare codice definendo alcune caratteristiche della classe, come il database o la funzione che analizza i cookies. Aggiungiamo al file server.py il seguente codice:

class BaseHandler(tornado.web.RequestHandler):
  @property
  def cursor(self):
    return self.application.cursor
  @property
  def database(self):
    return self.application.database
  def get_current_user(self):
    user_cookie = self.get_secure_cookie("AuthKey")
    if not user_cookie: return None
    return user_cookie

class HomePageHandler(BaseHandler):
  def get(self):
    if self.get_argument("msg", None) == "done":
      self.render("done.html", next=self.get_argument("next", "/") )
      return
    users = list()
    usersdata = self.cursor.execute("SELECT * FROM users ORDER BY time DESC LIMIT 20")
    for ( username, email, password, messages, time) in usersdata:
      users.append(username)
    users.reverse()
    messages = dict()
    messagesdata = self.cursor.execute("SELECT * FROM messages ORDER BY time DESC LIMIT 15")
    for ( url, username, msg, mtime) in messagesdata:
      messages[url] = dict()
      messages[url]["html"] = msg.decode("base64")
      messages[url]["time"] = mtime
      messages[url]["username"] = username
    messages_keys = messages.keys()
    messages_keys.sort()
    self.render("home.html", users=users, messages=messages, messages_keys=messages_keys

Analizzando il codice della classe HomeHandler notiamo la funzione get() che viene eseguita quando apriamo l’indirizzo a cui è assegnato l’handler. In questa funzione si leggono dal database gli ultimi 20 utenti iscritti, gli ultimi 15 messaggi scritti e si ottengono le informazioni dell’utente autenticato. La funzione self.render() si occupa di generare la pagina html dinamica, mediante gli input che gli vengono forniti come opzioni. A questo punto inseriamo gli Handler che gestiranno l’autenticazione, la registrazione ed il logout:

class LogInHandler(BaseHandler):
  def get(self):
    self.render("login.html")
  def post(self):
    username = self.get_argument("username")
    passwd = self.get_argument("passwd")
    OSha256 = hashlib.sha256()
    OSha256.update(username)
    OSha256.update(passwd)
    password = OSha256.hexdigest()
    existsuser = False
    usersdata = self.cursor.execute("SELECT * FROM users WHERE password = '%s'" %
    password)
    for ( username, email, password, amessages, atime) in usersdata:
      existuser = True #A quanto pare usare un semplice ciclo if non funziona
    if existsuser:
      import random
      random.seed()
      skey = random.randint(0, len(password)-1)
      OSha256 = hashlib.sha256()
      OSha256.update(username)
      OSha256.update(password)
      OSha256.update(str(skey))
      skey = OSha256.hexdigest()[:26]
      self.cursor.execute("INSERT INTO authkeys ( key, username ) VALUES ('%s', '%s')" %
       ( str(skey), username ) )
      self.set_secure_cookie("AuthKey", str(skey) + "@" + str(username))
      self.redirect(self.get_argument("next", "/"))
    else:
      self.redirect("/") #TODO: errore!

class LogOutHandler(BaseHandler):
  def get(self):
    if self.current_user:
      key = "@".join(self.current_user.split("@")[:-1])
      execthis = self.cursor.execute("""DELETE FROM authkeys WHERE key='%s'""" %
       key)
    self.clear_cookie("AuthKey")
    self.redirect(self.get_argument("next", "/"))

class JoinHandler(BaseHandler):
  def get(self):
    self.render("login.html")
  def post(self):
    now = time.ctime()
    username = self.get_argument("username")
    email = self.get_argument("email")
    passwd = self.get_argument("passwd")
    if not "@" in email and not passwd or not username:
      self.render("login.html")
      return
    OSha256 = hashlib.sha256()
    OSha256.update(username)
    OSha256.update(passwd)
    password = OSha256.hexdigest()
    self.cursor.execute("""INSERT INTO users ( username, email, password, messages, time) VALUES
     ('%s', '%s', '%s', 'hello', '%s')""" % ( username, email, password, now) )
    self.database.commit()
    self.redirect("/?msg=done&next=/auth/login") # Done!

Gli handler LogInHandler , LogOutHandler e JoinHandler lavorano prevalentemente nella tabella users e nella tabella authkeys del database che contengono i dati degli utenti e le chiavi di autenticazione. Infatti quando un utente si registra, si genera l’hash della sua password che viene inserita nel database assieme agli altri dati; mentre quando un utente fa il login si confronta l’hash della password che ha inserito con quella presente nel database: se le due chiavi saranno identiche sarà generato un cookie contenente una chiave segreta. Questa chiave viene salvata anche nella tabella authkeys e il confronto del cookie con il valore nel database permetterà di risalire al nome utente che si è autenticato ed ai suoi dati. Vediamo ora gli handler da aggiungere per creare e leggere nuovi messaggi. Scriviamo:

class NewPostHandler(BaseHandler):
  @tornado.web.authenticated
  def get(self):
    reply = self.get_argument("reply",None)
    if reply:
      messagesdata = self.cursor.execute("SELECT * FROM messages WHERE url = '%s'" % reply)
      username = reply
      for ( url, ausername, msg, mtime) in messagesdata:
        username = ausername
      self.render("write.html", reply=[reply,username] )
    self.render("write.html", reply=None)

  @tornado.web.authenticated
  def post(self):
    now = time.ctime()
    html = self.get_argument("message").encode("base64")
    #ricavo username e numero del messaggio.
    key = "@".join(self.current_user.split("@")[:-1])
    userdata = self.cursor.execute("SELECT * FROM authkeys WHERE key = '%s'" % key)
    username = None
    for (mkey, musername) in userdata:
      username = musername
    if username == None:
      self.redirect("/") # non autenticato 
      return
    #calcolo un indirizzo più corto
    OSha256 = hashlib.sha256()
    OSha256.update(html)
    shrt = OSha256.hexdigest()[:30]
    self.cursor.execute("""INSERT INTO messages ( url, username, html, time)
    VALUES ('%s', '%s', '%s', '%s')""" % ( shrt, username, html, now ) )
    usersdata = self.cursor.execute("SELECT * FROM users ORDER BY time DESC LIMIT 20")
    messages = []
    for ( username, email, password, amessages, atime) in usersdata:
      messages = amessages.split(",")
    messages.append(shrt)
    messages = ",".join(messages)
    self.cursor.execute("""UPDATE users SET messages = '%s'
    WHERE username = '%s'""" % ( messages, username) )
    self.database.commit()
    self.redirect("/%s" % shrt )

class ReadHandler(BaseHandler):
  def get(self,shrt):
    messages = dict()
    messagesdata = self.cursor.execute("SELECT * FROM messages WHERE url = '%s'" % shrt)
    for ( url, username, msg, mtime) in messagesdata:
      messages[url] = dict()
      messages[url]["html"] = msg.decode("base64")
      messages[url]["time"] = mtime
      messages[url]["username"] = username
    messages_keys = messages.keys()
    messages_keys.sort()
    self.render("message.html", messages=messages, messages_keys=messages_keys)

Quando un utente è autenticato e visita la pagina /write, potrà scrivere un messaggio e inviarlo. Cosa accade? Il messaggio inviato viene ricevuto dal NewPostHandler il quale analizza il messaggio ricevuto e lo inserisce all’interno della tabella dei messaggi. Successivamente aggiunge il messaggio sul profilo dell’utente che lo ha scritto: così facendo dal profilo dell’utente potremo vedere i suoi messaggi. Ogni messaggio ha un suo indirizzo, che corrisponde ad una parte del suo hash: ad ogni messaggio corrisponde un solo hash e quindi anche un solo URL. Quando si visita l’indirizzo del messaggio scritto, ReadHandler riceve l’hash e lo ricerca nel database, ricava tutte le informazioni e rielabora la pagina messages.html in modo da mostrare il contenuto al visitatore.

Il codice del nostro motore va solamente ultimato. Aggiungiamo le seguenti righe di codice al file server.py:

def main():
  if not os.path.isfile("database.sql"):
    print "Generating the database:",
    database = sqlite.connect("database.sql")
    cursor =  database.cursor()
	# Scelto tutto testo per comodita'
    cursor.execute("""CREATE TABLE authkeys ( key TEXT NOT NULL, username TEXT NOT NULL)""")
    cursor.execute("""CREATE TABLE users ( username TEXT NOT NULL, email TEXT NOT NULL,
    password TEXT, messages TEXT, time TEXT)""")
    cursor.execute("""CREATE TABLE messages ( url TEXT NOT NULL, username TEXT NOT NULL,
    html TEXT NOT NULL, time TEXT)""")
    cursor.execute("""INSERT INTO messages ( url, username, html, time) VALUES
    ('%s', '%s', '%s', '%s')""" % ( "hello", "admin", "hello world!".encode("base64"), "ever" ) )
    database.commit()
    database.close()
    print "done"
    sys.exit(0)
  tornado.options.parse_command_line()
  http_server = tornado.httpserver.HTTPServer(Application())
  http_server.listen(options.port)
  tornado.ioloop.IOLoop.instance().start()

Queste righe si occuperanno di generare il database nel caso non esista, e di avviare il nostro Social Network. Al primo avvio, il programma controllerà se esiste o meno il database. Nel caso non esista lo costruirà e terminerà. A questo punto il nostro social network è quasi ultimato, non ci resta altro che scrivere le pagine html dinamiche ed aggiungere un foglio di stile. Per rendere questo post più breve e facile da comprendere prenderò in considerazione solamente il file home.html che viene rielaborato da HomePageHandler.

Quando avevamo definito le impostazioni dell’applicazione avevamo inserito le seguenti righe:

template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),

Ciò significa che le pagine html dinamiche  si troveranno nella cartella templates mentre le pagine statiche nella cartella static. Quindi creiamo queste due cartelle e spostiamoci all’interno della prima per scrivere il file base.html ed home.html. Il file base.html non è altro che la pagina HTML principale. Questa pagina è vuota ed è divisa in dei blocchi. Così facendo non si deve riscrivere più volte lo stesso codice HTML e si riducono le possibilità di avere problemi. Quindi scriviamo allinterno del file base.html il seguente codice:

<html>
  <head>
    <title>{{ handler.settings["social_name"] }}</title>
    <link rel="stylesheet" href="{{ static_url("style.css") }}" type="text/css"/>
        {% block head %}{% end %}
  </head>
  <body>
	  <div id "igloo-body">
      <div id="igloo-header">
	<div style="float:right" align="right">
	  {% if current_user %}
	    <a href="/auth/logout?next={{ url_escape(request.uri) }}">
            {{ _("Log out") }}</a>
        <br><a href="/write">{{ _("New post") }}</a>
        {% else %}
	    {{ _('<a href="%(url)s">Log in</a>') %
            {"url": "/auth/login?next=" + url_escape(request.uri)} }}<br>
	  {% end %}
	</div>
	<h1><a href="/">Siderus Igloo</a></h1>
      </div>
      <div id="igloo-content"><div id="igloo-spaces"></div>
      {% block body %}{% end %}

      </div>
    </div>
    </div>
    <div id="igloo-footer">
    {% block bottom %}{% end %}
    Powered by: <a href="http://www.tornadoweb.org">Tornado</a> -
    <a href="http://www.siderus.org">Siderus</a> -
    <a href="http://www.koalalorenzo.com">koalalorenzo</a> 
    </div>
  </body>
</html>

Come detto prima, la pagina è divisa in blocchi dinamici, ossia degli spazi vuoti che possono essere riempiti in base alle nostre necessità. Ad esempio il blocco body racchiuderà il corpo della nostra pagina. Per capire meglio ciò osserviamo e scriviamo il seguente codice nel file  home.html :

{% extends "base.html" %}

{% block body %}
  <div id="users">
  Ultimi utenti registrati:
  <ul type="disc">
  {% for user in users %}
    <li>{{ user }}</li>
  {% end %}
  </ul>
  </div>

  <div id="messages">
  {% for shrt in messages_keys %}
     <div class="message">
     {{ messages[shrt]["html"] }}
     <div class="under-message"><a href="/{{ shrt }}">
    {{ messages[shrt]["time"] }} -
    {{  messages[shrt]["username"] }}</a>
    {% if current_user %}<a class="button"
    href="/write?reply={{ shrt }}">reply</a>{% end %}</div>
     </div>
     <br>
  {% end %}
  </div>
{% end %}

Da come si vede dal primo rigo, la pagina base.html viene estesa con i blocchi dinamici della pagina home.html così da generare la HomePage. Quando abbiamo scritto HomePageHandler avevamo inserito la seguente riga:

self.render("home.html", users=users, messages=messages)

Le opzioni passate alla funzione render() le ritroviamo come valori nel file home.html ad esempio:

• il valore users corrisponde ad una lista, e nel codice html dinamico viene avviato un ciclo for per analizzare i suoi elementi.
• il valore messages è un dizionario che mantiene i dati degli ultimi messaggi. Per questo troviamo un altro ciclo for che analizza tutti gli elementi del dizionario.

Da come si può intuitivamente capire i cicli vengono introdotti dai tag {% e chiusi da %} mentre tramite le doppie parentesi graffe {{ e }} vengono sostituite direttamente con un valore passato come opzione. Con un po’ di sana pratica capirete il funzionamento del generatore delle pagine HTML in Tornado. È più difficile spiegarlo che metterlo in pratica! Anche per questo ho deciso di tralasciare le altre pagine dinamiche (che ho comunque realizzato ed inserito nel pacchetto con i sorgenti).

A questo punto non ci resta che spostarci nella cartella static ed inserire i file statici. Possiamo inserire l’icona ( favicon ) ed il foglio di stile ( style.css ). Le pagine statiche non vengono rielaborate da Tornado, ma vengono prese in considerazione e sono raggiungibili con l’indirizzo /static/.

Una volta realizzato il vostro foglio di stile, torniamo nella cartella principale e digitiamo da terminale:

sudo python ./server.py

Così facendo il nostro motore costruirà un database, ma dovremo ri-eseguire il comando per avviare il server e poter utilizzare il nostro social network appena creato. Quindi apriamo un browser e visitiamo la pagina all’indirizzo:

http://127.0.0.1/

Congratulazioni! Avete "finito" !

Realizzare un Social Network è complicato. C’è tanto che è stato tralasciato, come l’utilizzo delle email, la gestione degli errori, i profili degli utenti e le relazioni tra di loro… Questo articolo affronta solamente una parte del discorso legato allo sviluppo, poiché credo che ci sia molto più lavoro dietro: per non allungare troppo e renderlo noioso, ho deciso di troncare questa guida e ridurre le funzioni che avevo in mente ( like, analisi delle risposte, gestione dei profili degli utenti, email e amicizie etc… etc…) ma ho pensato di rendere disponibile il codice che ho scritto. Grazie a Tornado ed a questa “base” sarà facile implementare/migliorare le funzioni del vostro social network. Come un preparato per torte: basta aggiungere dell’acqua e metterlo nel forno a 150° Nel caso utilizzerete questo codice vi chiedo solamente di non modificare il footer contenente un link a questo blog. Spero vi possa tornare utile:

Scarica i sorgenti: http://www.koalalorenzo.com/source/social-igloo.tar.gz

Tutto codice ed il testo in questa pagina è rilasciato sotto licenza GPL v3
Copyright (C) 2010 Lorenzo Setale

Tornado Web Server

Attenzione! Questo articolo è altamente nerd!

Dannazione! ho perso la connessione ssh! Ed ora? uffa!!!

Potevi pensarci prima! Avresti potuto utilizzare Screen! Questo comodo tool mi ha salvato più volte la vita della mia Gentoo su Akira. Oltre a salvarmi una sessione e condividerla tra più schermi mi ha dato la possibilità di avviare processi, e senza interromperli uscire e chiudere la sessione ssh, per poi ritornare in un secondo momento. Tramite screen infatti è possibile gestire e realizzare differenti schermate o terminali.

Installiamo screen con questi semplici comandi:

sudo apt-get install screen

Oppure per chi fosse come me su Gentoo:

sudo emerge app-misc/screen

Ed il gioco è fatto! Cosa dovremo fare? Avviare un nuovo schermo:

screen

TADÀ Da questo momento in poi siete in un nuovo mondo ma non completamente differente. Vi basterà controllare screen mediante semplici combinazioni di tasti preceduti da “Ctrl + A“. Ho deciso di riportare quelle che più utilizzo:

Ctrl + A + C              Crea una nuova finestra
Ctrl + A + N              Spostati sulla finestra successiva
Ctrl + A + P              Spostati sulla finestra precedente
Ctrl + A + K              Chiudi e termina la finestra ed i processi in esecuzione
Ctrl + A + D              Sospendi ritornando alla tua shell (non termina il processo)

Certo ci sono tante altre combinazioni, ma lascerò parlare manpages, altrimenti a cosa serve? Giocherellando si prende la mano e si comprende quanto questo strumento sia facile, veloce ed utile. Io come lo uso? in questo modo. Prima di tutto avvio screen come demone, così facendo resterà in backgroud e potrò accedere ovunque. Quindi digito:

screen -dmS MyPid

Quando screen sarà avviato, avvio una shell ssh e digito questo comando per entrare nella sessione che avevo appena reso demone:

screen -x

E sono subito pronto per emergere il mondo senza alcun rischio! Semplice no?

Questo è un CD che mi è stato dato durante l'Ignite del 4 marzo

Nel lettore CD è ovvio!
il problema è trovare un lettore CD per ascoltare questa sana musica

Le reazioni erano più che scontate:

Su IRC:
koalalorenzo su gentoo??? dai non ci credo! Sarà uno scherzo!

Su Twitter:
Tu gentoo?

Su Facebook:
Mah…

I fatti stanno così: ho un netbook che posso usare tranquillamente, debian mi ha lasciato a piedi e devo ritornare a scrivere su questo blog!

Proprio per quest’ultimo motivo ho deciso di installare Gentoo Linux. Il mondo GNU/Linux è diventato troppo semplice e troppo facile, oramai non si possono più scrivere quei post da vero hacker, quei post dove senti proprio lo gnu che con le sue corna ti punzecchia e stimola a smanettare. Nah, GNU/Linux non è più quello di una volta, e quelle poche guide che si riescono a scrivere sono veramente banali… e per questo preferisco fare silenzio, invece che realizzare articoli su, ad esempio: come cercare un blog decente su google

Gentoo è da masochisti, così come LFS. L’ho detto e lo continuerò a dirlo. È un dato di fatto, una cosa oggettiva che tutti quanti sanno: quando scrissi del mio passaggio ad Arch Linux e poi di nuovo a Debian ed Ubuntu dissi che preferivo avere una suite completa e pronta da usare. Un sistema operativo subito reattivo, capace di farmi lavorare sin dal primo istante. ehi cavolo! mi sbagliavo di grande!

Se “lavorare” significa anche scrivere dei post sull’informatica, internet, ed in particolar modo di GNU/Linux, allora un sistema operativo stabile e reattivo non fa per me. Se tutto funziona alla perfezione, di cosa scrivo? Di come si cerca un blog decente su google?

Allora la divina provvidenza ha accelerato i tempi: un messaggio mi è comparso sullo schermo: È arrivato il momento di Gentoo!

Il logo di Meemi

Ho deciso di riscrivere quello che ho già detto su qui Meemi

Comunque è vero, Meemi è molto più “possente” rispetto a qualsiasi altro social e non lo dico per spirito di gruppo o perché ho fettine di carne sugli occhi, ma perché è pura verità. L’ambiente che si è realizzato con il tempo è unico e speciale, vicino alla mia idea di utenti del web 3.0 :

Prima di tutto Meemi conta una comunità affiatatissima, nulla in confronto a Facebook, Twitter e FF!

In secondo luogo aggiungerei lo sviluppo continuo del progetto e la possibilità di rispondere con contenuti di vario tipo: dire caffè non è la stessa cosa rispetto a quando c’è una foto di una tazzina con dei cornetti!

Vogliamo mettere in discussione anche il tipo di ambiente?
Se si riprende il discorso degli ambienti di cui parlavo nel video che ho registrato (si però questa volta non lo dico per far ridere), come ha giustamente detto @ilmacaco, e @pikadilly stessa, l’utenza è reale e parla di cose reali.

Non come su Facebook dove (perlomeno a me) trovo sempre “se non ricondividi morirai” o “L’amore è come il vento e bla bla bla bla”, oppure persone che se gli sputi in faccia nella vita reale poi ti fanno la richiesta d’amicizia! Non come su FF e Twitter dove le persone sono regredite al web 1.0, parlando in inglese o solamente di se stesse senza neanche interessarsi agli altri! Molte volte (come ha detto giustamente @Pimkadilly) il contenuto non è di tipo Personale, ma mira solamente ad un discorso di “Mode” e “Sviluppo“. Che barboso quel mondo lì!

Qui no, è tutto diverso, qui si parla di tutto e di tutti su tutti e con tutti! Meemi è un’oasi felice in mezzo ad un mondo triste e monotono, dove la vita reale non tocca la vita virtuale.

Il web 3.0 arriverà quando la vita reale sarà un tutt’uno con la vita virtuale.
Per questo credo che Meemi sia un passo avanti per il web 3.0 e spero che @Capobecchino sfrutti al massimo questo concetto per portare avanti il suo fantastico progetto.

C’è del reale in ognuno di noi, e per questo l’ambiente che si è formato su Meemi è un passo avanti rispetto agli altri.

Per chi fosse interessato solamente al web 3.0, può iniziare a vedere il video dal minuto 4:38!

Ho deciso di realizzare questo noioso video di 8 lunghi minuti, nel quale racconto brevemente l’evoluzione del web e le relazioni che ci sono tra l’utente e la rete. Ho provato a descrivere il web 1.0, il web 2.0 e ciò che credo accadrà nel web 3.0. Il concetto già l’avevo espresso su altri vecchi post su questo blog, ma questa volta ho deciso di metterci la mia brutta faccia!

Lo ammetto subito: non sapevo come iniziare, ed ho deciso di gettare un stupido jingle e presentarmi direttamente… Si vede che è il mio primo video?

La sacra Bibbia

Una tavola di polistirolo

…ed ovviamente:

Un iPad

Facebook Primordiale

Io credo che la vita, intesa come insieme di reazioni a stimoli, sia basata sulle relazioni e sulle connessioni che avvengono tra gli esseri. Ad esempio si è studiato che le stesse piante comunicano, scambiandosi messaggi chimici, ma anche mediante i colori: le foglie che cadono o le spine appuntite, sono messaggi abbastanza chiari!

Scendendo ancora nel particolare, ed azzardando un pochino, un essere pluricellulare è una società di cellule: queste ultime si sono aggregate per aumentare le possibilità di sopravvivenza, “socializzando” fra di loro. Non a caso esistono degli stimoli e dei messaggi che queste si trasmettono: il fattore crescita è uno dei tanti messaggi che permette alla cellula di moltiplicarsi o meno! Per questo motivo credo che, non solo l’uomo, ma tutto il mondo che ci circonda, sia un mondo sociale. Un mondo fatto da una quantità innumerevoli di connessioni. La nostra astronave blu è sociale.

Come in passato la posta, adesso Internet è un nuovo modo per socializzare: Il web 2.0 è formato prevalentemente da connessioni tra utenti. Si sviluppano relazioni più o meno complesse, che molte volte uniscono persone anche agli antipodi del pianeta! E dato che Socializzare è tanto naturale quanto spontaneo, perché non farlo sfruttando anche le nuove tecnologie?

Hacker: il parolone che scatena paura!

Proprio in questo momento sto guardando un telegiornale in cui la rete è stata definita “posto insicuro”.

Questa è una concezione legata sia al vecchio Web 1.0 sia al pensiero chiuso di alcune persone. Non voglio puntare il dito contro tutte quelle persone che non sono in grado di scrivere un SMS. Non voglio neanche parlare male delle persone di una certa età, che hanno delle difficoltà con l’utilizzo delle tecnologie e dell’informatica. Voglio parlare di tutte quelle persone che hanno associato il mondo di Internet ad un mondo fasullo ed Irreale, legato alla illegalità ed alla pornografia. Ci sono persone che credono che sia differente stringere relazioni mediante la rete. Queste persone, molte volte, fanno ancora la distinzione tra mondo reale e mondo virtuale. Molte volte si pensa che tutto ciò che accade in internet sia fine a se stesso. Non è sempre così.

Ebay

Uno dei primi servizi-pionieri del web 2.0 è stato eBay: milioni di persone si sono messe in contatto per scambiarsi, vendersi e comperare materiale di ogni genere. Un esempio di socializzazione lampante: le persone mediante internet possono stringere relazioni commerciali, accorciando le distanze ed abbattendo gran parte dei costi. Un altro esempio può essere la messaggistica istantanea, il Voip e, solo da poco, il web su piattaforme mobili: Internet non è fasullo.
Con la nascita dei Social Network è stato più facile mettere in contatto le persone. Di certo i primi esseri pluricellulari non utilizzavano Skype o non avevano un NexusOne, ma di sicuro socializzavano mediante reazioni chimiche. Perché non fare lo stesso con internet e le nuove tecnologie?

Emh... ecco vedi...

Quello che mi incuriosisce di più è un certo atteggiamento che si è manifestato dopo l’apparente chiusura del suo blog. Per molti di noi era diventato quasi quotidiano seguire il suo feed o recarci sul suo spazio per leggere le interminabili e continue novità. Era un luogo sacro… un luogo sacro di lettura: come dice lui stesso, era divenuto il blogger italiano più seguito su wordpress.com E di questo sono contento. Non al 100%, ma sono contento.

Il potere di Internet è un potere strano: a differenza della TV, dove il messaggio trasmesso arriva e non può essere discusso, su Internet ( specialmente nel web 2.0 ) si può parlare e sparlare. Si possono aggregare gruppi di persone che condividono le stesse idee. La perdita di Felipe in poco tempo, ha generato un collasso tale, che molti blogger del software libero anno preso la palla al balzo e si sono armati di ambizione. Annebbiati dalla presunzione, un pochino tutti ci siamo ritrovati nel vuoto: i blogger non sapevano più cosa rebloggare e i lettori non sapevano più cosa leggere. Tutti scrivevano le stesse cazzate e tutti leggevano le stesse cazzate di sempre.

L’era dei cloni difettosi e dei ribelli.

Solo pochi blogger personali si sono salvati: parlo dei blogger che si aprono il sedere per gli altri, che testano sulla propria pelle e che condividono le proprie esperienze nell’ambito informatico divulgando realmente parole libere. Il mio amico Doc ne è un esempio! Al contrario c’è chi non sa fare altro che scrivere quel suo post quotidiano che dice poco e nulla. Ma anche: Parli come mangi.

Ed ora il ritorno di Felipe. Ha venduto, ha fatto bene: avrei fatto anche io lo stesso, e non credo sia stata una mossa sbagliata. Per fortuna ha salvato gran parte dei contenuti: Molte guide sono ancora utilizzabili, anche se c’è sempre di mezzo lo zampino del tempo!

Come una maestra che batte sulla cattedra per richiamare l’ordine nella classe, Felipe sta battendo sul suo Pollycoke per ottenere lo stesso effetto: ordine! ordine! Ci riuscirà? Oppure continuerà ad essere re-bloggato da tutti quanti? Di questo poco importa…

Ma tutto ciò mi sembra strano: non sembra lui. Mi ha risposto sul mio blog, cosa che prima d’ora non ha mai fatto. Però sono aperto alle novità ed al diverso, e credo che le persone possano cambiare… quindi: perché no? Forse mi piacerà il nuovo pollycoke… Speriamo solo non ci riempa di nuovo i nostri reader delle sue news o delle traduzioni dai vari planet: C’è bisogno di un blog non di una testata giornalistica! Ma già il fatto che utilizzi la 3a persona al posto della prima, mi fa sentire meglio: coinvolge di più e fa molto social network. Forse non è peggiorato

Ben tornato caro! Spero che queste parole ti possano tornare utili e farti capire quanto siamo caduti in basso durante la tua assenza

Siamo e sono

La casa dei koala

Mentre ascolto LittleBoots ed ordino un caffè, ho deciso di scrivere questo breve articolo su Posterous: Molti di voi già saranno andati a visitare il mio nuovo spazio personale, e probabilmente avrete notato che dietro l’Eucalipto c’é Posterous.

Posterous è comodo. Anche se esistono alternative, credo che sia veramente comodo. Gestire i propri blog, scrivere contenuti ed aggiungere file multimediali, per me è diventato una barzelletta. Da qualsiasi parte del mondo, mi basta inviare una email a post@posterous.com per archiviare tutto ciò che mi passa per la mente… e non solo. Ero indeciso tra Tumblr e Posterous: il primo è ancora troppo blog, ed è troppo statico, mentre il secondo è identico al primo, solo che ha delle funzioni che mi facilitano il suo utilizzo.

L’idea di sfruttare la posta elettronica invece dei classici feed, o di una pagina web dinamica, è geniale. Credo che alla base di tutto ci sia la mia pigrizia: Le email vengono incontro a me, e non sono io che devo andare ad aprire il feed reader o la pagina web specifica! Per me è vitale essere aggiornato su ciò che scrivono i miei amici sparsi per i social network, ma mi viene difficile recarmi in tutti i siti, aprire le pagine, commentare e pubblicare nuovi contenuti: una volta al giorno mi vengono notificate via email le novità dei posterous a cui sono iscritto.

L’integrazione con la maggior parte dei social network esistenti e con altre piattaforme e CMS, mi ha convinto seriamente a passare a Posterous: Con il cellulare posso aggiornare il mio Eucalipto e condividere ovunque e con chiunque qualsiasi cosa io voglia. Non mi è più difficile.

Certo, è possibile fare tutto ciò installando Wordpress su un qualsiasi spazio, e configurando un indirizzo email privato a cui inviare i contenuti… ma non è la stessa cosa: per avere tutto ciò che fa Posterous dovrei smanettare con plugin e configurazioni varie. Ed io non ho tempo da perdere! Quando ho creato l’eucalipto ho veramente capito che è un servizio ben fatto e completo sotto la maggior parte dei punti di vista: Mi è bastato inviare una email per creare il mio spazio!

È Tumblr con una marcia in più! Ora scrivere post è diventato un piacere e non vedo l’ora di inviare una nuova email

Prima di ogni altra cosa: il ritorno di pollycoke ha generato un mini-putiferio. Hanno scritto, scritto e riscritto… ma il polverone che si è alzato non è stato lo stesso di quando il noto felipe si è auto-intervistato. Come ho fatto in precedenza, preferisco non commentare: ci sono troppe persone con la bocca sporca di merda ed anche se direi «ha fatto la mossa giusta» potrebbero esserci estremisti pronti con la falce e la forca.

Ho un nuovo amichetto: Compaq Mini 110c. Niente di speciale: come tutti i netbook di fascia media è abbastanza potente da permettermi di scrivere questo post da sotto le coperte, compilare un pacchetto su Akira, chattare e stringere nuove amicizie. Peccato per il wi-fi: anche il modulo proprietario del kernel non funziona bene, e quindi, temporaneamente, sono costretto ad utilizzare un luuuuungo cavo ma mi accontento: sono tornato ad essere un debianaro!

Mentre mi sciolgo e rattristo, per le storie d’amore altrui, mi accorgo che questo mio blog ha più di qualche problema: Non ho un Tema-Stile fisso e barcollo tra il blog “tecnico” (si fa per dire) ed il blog personale. Già. Alcune volte spuntano articoli come questi, altre volte scrivo delle guide in base alle mie esperienze, pareri e news: stavo in pace con me stesso… Ma sono entrato in crisi quando ho scoperto Posterous e non ho potuto più farne a meno! È così comodo!

Tra i tanti pensieri che mi sono passati per la mente in questi giorni, ho scoperto che ci vuole ancora un tocco di Web2.0 : Qualche piccola modifica, in stile Pì, ombre, trasparenze ed opacità, senza eccedere e senza mutilare.

Spero che entro la fine del mese, questo spazio diventerà un blog semi personale: scriverò articoli di carattere personale, di argomento prevalentemente tecnologico, ma lasciando spazio anche alla mia incontenibile voglia di essere utile agli altri. Vorrei essere koalalorenzo, invece di Lorenzo o Koala Ed il Posterous? continuerà ad esistere: lo utilizzerò per realizzare una specie di Tumblr, dove raggruppare tutti i contenuti che su questo blog non potrei scrivere. Avevo in mente di usarlo anche come Foto-blog, ma ho preferito evitare: non è il caso.

E la notizia più importante? Magari di quello, scriviamo un altro giorno: capita a tutti prima o poi no?

Attenti con i fuochi d'artificio!

Auguri di buon anno!

Anche se non potrò esserci, per motivi di famiglia, spero che tutti voi possiate passare una buona serata, e vi auguro un felice anno nuovo, con la speranza che sia migliore di quello passato!

FERMI TUTTI! c’è Gnome!

Così, in preda al panico ho deciso di installare Xfce senza alterare la configurazione dell’interfaccia grafica: Utilizzo un altro DE ma lascio le stesse impostazioni, in modo da non avere un pugno in un occhio. Così mi sono rimboccato le maniche ed ho subito aperto un terminale.

Inizialmente, credevo non ci fosse modo di installare Xfce, in quanto dopo l’installazione non vengono aggiornati i database, e per questo ho dovuto farlo manualmente. Infatti ho aperto un terminale ed ho digitato:

sudo apt-get update

Finito il processo ho deciso di installare Xfce, un plugin per thunar e un plugin per il pannello.  Quinid ho digitato il seguente comando:

sudo apt-get install xfce4 xfce4-goodies thunar-archive-plugin xfce-xfapplet-plugin

al termine del processo ho dovuto chiudere la sessione:  Andando nel pannello principale, ho cliccato sul pulsante Esci… e successivamente dalla finestra che mi si è aperta ho selezionato Disconnetti. Chiusa la sessione, ho dovuto rifare il login, ma prima di inserire username e password ho cliccato sul pulsante  in basso a destra e selezionato la voce Select Session dal menu. Nella  finestra, che è comparsa,è stato necessario selezionare come opzione Xfce Session in modo da avviare il DE appena installato.

Una volta entrato mi sono sentito catapultato in un nuovo mondo: Xfce si presenta con le sue caratteristiche standard, o quasi. Il pannello principale in basso ricorda molto Windows ma si può rimediare. Per prima cosa ho cliccato con il tasto destro su di esso ed ho selezionato la voce Customize Panel… puff! una finestra di configurazione mi ha aiutato nel posizionare il pannello: Nel gruppo di pulsanti, che raffigurano lo schermo, ho cliccato sul pulsante centrale in alto (Come mostrato in figura).

Configurare il pannello di Xfce

Vai con la fantasia!

Una volta settato il pannello superiore, cliccando con il tasto sugli elementi, sarà possibile aggiungerne, spostarli o rimuoverli a proprio piacimento. Se si aggiunge l’elemento XfApplet sarà possibile selezionare gli elementi del pannello di Gnome, inclusi anche quelli realizzati per Jolicloud. Ad esempio per aggiungere l’elemento per il controllo del Capslock e Numlock in Xfce, basterà cliccare con il tasto destro su un punto vuoto del pannello, selezionare dal menu la voce Add New Items. All’interno della finestra che si sarà aperta, bisogna selezionare il plugin  XfApplet e successivamente cliccare sul pulsante Add. Dopo pochi secondi, si aprirà una seconda finestra per configurare il contenuto di questo elemento appena inserito. Quindi selezioniamo dalla lista di opzioni l’elemento chiamato Lock Keys e clicchiamo sul pulsante ok.

Ci sono una marea di configurazioni possibili, infatti è anche possibile disattivare l’interfaccia di accesso ai programmi e riabilitare il desktop. Per fare ciò dalle impostazioni ( o Preferences o anche  Menu > Impostazioni ) si selezioni Xfce 4 Settings Manager. Dalla finestra che si aprirà cliccare sul pulsante con scritto Sessione ed Avvio. Nella finestra appena aperta è necessario cliccare sulla tabella Application Autostart dove si potrà modificare la lista di applicazioni da eseguire all’avvio. Tra queste si può notare che il programma Netbook Laucher è abilitato: vi basterà disabilitarlo per non farlo più avviare quando accederete al sistema.

Abilitare e/o disabilitare Notebook Launcher

Al suo posto sarà impostato il classico Desktop, con le amate iconcine e gli sfondi personalizzabili! Quindi riavviate la sessione per applicare i cambiamenti.

Un altro problema risolvibile facilmente, è quello del tema GTK delle icone. Infatti ho optato per riutilizzare il gradevole tema utilizzato dalla distribuzione in Gnome. Dal menu principale ho cliccato sul pulsante Impostazioni > Aspetto ( o Appearance ) selezionando prima lo stile GTK chiamato Jolicloud e poi dalla tabella delle icone ( Icons ) ho impostato il set di icone chiamato Jolicloud. ( che fantasia! )

Detto fatto! Ora il vostro Jolicloud, invece di consumarvi 300MB di ram circa, ve ne consumerà di meno, (circa 160MB ) permettendovi di eseguire applicazioni più pesanti. Nulla è cambiato: le applicazioni si continuano ad installare comodamente dal programma MyJolicloud. Certo, questo ha un piccolo costo, ma ci si abitua molto facilmente in quanto, oltre ad essere insignificanti, sono anche poche le differenze tra un Jolicloud con Gnome ed un Jolicloud con Xfce Giusto il colore del pannello e Maximus che raramente fa i capricci. Ma il mouse si muove, la tastiera funziona e la connessione ad internet è stabile: Questo importa veramente

Per chi fosse interessato ad alcuni screenshot, è possibile visualizzarli nel mio vecchio post!

Buon natale!

Auguri di buon natale e felice anno nuovo!