Wikileaks a "palle ferme"

Cercherò di esporre il mio punto di vista sulla vicenda Wikileaks ora che tutti si sono un po' calmati.
Ci sono diversi aspetti che mi hanno colpito di questa vicenda.
Il primo è l'accanimento nei confronti di una persona: tale Julian Assange.
Il personaggio che è stato sulla bocca di tutti i politici (anche con pronunce discutibili) è quello raffigurato nella foto accanto con una pettinatura improbabile, oramai domata. Assange è sì il "publisher" di tutto quello che è all'interno del sito Wikileaks ma non è mica il diplomatico americano che si è lasciato sfuggire i documenti pubblicati. In pratica c'è una diga che fa acqua da tutte le parti e viene incolpato il povero contadino che intervistato al telegiornale dice "guardate che fra un po' si rompe tutto". Questo aspetto non deve tenere conto dell'accusa di violenza sessuale che dev'essere discussa in altra sede.
Lo dico subito: secondo me la pubblicazione di questo materiale rientra nella libertà di stampa. Ai posteri l'ardua sentenza.
Il secondo aspetto che mi ha colpito è l'anacronismo delle dichiarazioni dei politici (nessuna smentita sul contenuto, tanto per dire) e dei mezzi atti a contrastare il flusso costante di materiale pubblicato.
Tutti gli stati si sono lanciati in accuse di qua, insulti di là e certe volte deliri. Nessuno però si è reso conto che siamo nel 2010 e che tutta la rete è invasa di informazioni private di tutti. Se nel calderone generale ci finiscono anche i documenti filtrati dalle ambasciate non c'è nulla di cui stupirsi. Il problema, se ce n'è uno a livello informatico, è come sia stato possibile che le politiche di sicurezza statunitensi abbiano lasciato questi enormi buchi e, se ce n'è uno a livello diplomatico, com'è possibile che nessuno prenda le distanze da quanto scritto in questi compromettenti documenti.
Veniamo ora all'aspetto tecnico che più interessa. Come prevedibile non appena è stato bloccato dai dns il nome www.wikileaks.org sono nati una tonnellata di mirror che si rimbalzano le informazioni. Non contiamo ovviamente i servizi p2p ecc. perchè rischiamo di far venire dei mal di testa ai piani alti.
Ovviamente una volta pubblicati su internet i documenti sono stati sottoposti a multipli wget -r per poter essere conservati anche dopo tutte le opere di censura.

Spero veramente che i vertici capiscano che i giorni dei rapporti diplomatici 1.0 sono finiti. Oramai non solo il web ma anche la vita sta diventando 2.0 quindi è bene che tutti i rapporti che si stringono siano trasparenti e privi di giochetti da guerra fredda. Il risultato se no è un sito che colleziona, un hacker che viene incolpato mentre ce ne sono altri 100.000 che continuano a pubblicare e a mantenere viva questa isola di libertà, una marea di cazzate dette da politici disinformati e una brutta figura planetaria.

Regards ;)

SQLite - Il database da taschino

Avere il supporto di un database all'interno di un'applicazione aiuta ad immagazzinare i dati, a tenerli in ordine ed a consultarli con efficienza.

SQLite (http://www.sqlite.org/) è un database relazionale che sta all'interno delle applicazioni e permette di fare tutto ciò che solitamente richiederebbe una database tradizionale diviso in client e server (leggere MySQL, PostgreeSQL).

Per ora ho provato l'integrazione solo con due linguaggi, C++/Qt4 e Java.

In entrambi i casi i risultati sono stati ottimi e l'integrazione è stata rapidissima.

QT4
Qt4 mette a disposizione una libreria per interagire con il db. Ecco uno stralcio di codice che permette di misurare il tempo di esecuzione di due semplici query.

int main(int argc, char *argv[])
{

  QTime t;
  t.start();
  QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");


  db.setDatabaseName("qt.db");
  db.open();

  QSqlQuery * query = new QSqlQuery("insert into T1 values (1,'Insert from program.');",db);

  int result = 1;
  result = (query->exec()) ?  0 : -1;

  query->prepare("SELECT * FROM T1;");
  query->exec();

  while(query->next())
  {
      QString line = query->value(0).toString() + ","+query->value(1).toString();
      QString deb = "Linea trovata: " + line;
      qDebug(deb.toStdString().c_str());

  }


  int elapsed = t.elapsed();

  return elapsed;
}

Facendo girare il programma sul mio laptop il tempo di esecuzione è stato di 3 millisecondi. Un ottimo risultato direi.
Java
Ecco un piccolo esempio di codice Java che fa la stessa cosa.

public static void main(String[] args) throws SQLException {
    try {
        Class.forName("org.sqlite.JDBC");

        Connection conn = DriverManager.getConnection("jdbc:sqlite:test.db");
        Statement stat = conn.createStatement();
        stat.executeUpdate("insert into T1 values (1,'Insert from program.');");
    } catch (ClassNotFoundException ex) {
        Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
    }
}

Con il la parte di codice scritta in Java non ho eseguito dei test di performance ma ha garantito una portabilità incredibile visto che il file .jar contiene al suo interno la libreria per interagire con il database.

Questo è solo un primo articolo che vuole fornire lo spunto a tutti quelli che verranno. Spero di essere stato utile.

Alla prossima.

Esplorando il kernel Linux: boot

Cominciando il mio viaggio all'interno del kernel Linux mi sono posto una domanda: come fa Linux a partire?

Ho cercato e trovato online un link molto interessante che voglio condividere: LINK

In questo articolo viene dettagliato il processo di boot del kernel linux in tutte le sue fasi.

Questi passi possono essere ritrovati all'interno del codice sorgente. A questo proposito a questo indirizzo è possibile consultare il codice sorgente on-line molto comodamente e poter riferire ogni singola linea di codice tramite il bookmark che si trova sotto il numero.

Buona lettura.

How to install Hping3 from source code

Nella mia nuova Slackbox mancava uno strumento che è oggetto di studio da parte di un corso universitario che seguo:

hping

Mi sono così procurato i sorgenti da http://www.hping.org/ e ho effettuato i soliti comandi:

./configure
make...

ecco che spunta un errore:
libpcap_stuff.c alla linea 61 non riesce a trovare una funzione che si trova nel sorgente net/bpf.h

Installo allora le librerie che vengono riportate in alcuni siti: http://www.tcpdump.org/ e più precisamente la libreria libpcap.

Queste librerie vengono installate facilmente eseguendo:

./configure
make
make install

Il file bpf.h viene però posizionato male.
Dando questi comandi è possibile vedere come il file di nostro interesse si trovi dentro pcap e che la cartella net non è stata creata per niente.

# cd /usr/local/include/
# cd pcap
# ls

Diamo allora i seguenti comandi:

# mkdir ../net
# cp *.h ../net/

Dopo di che posizioniamoci nella directory con i file sorgenti di Hping3 e diamo in sequenza:

./configure
make
make install

Il risultato sarà questo:

root@slackbox:~# hping3
hping3>

Buon divertimento con Hping3.

How to write Spamassassin plugin - part 2

Come promesso eccoci al secondo e ultimo appuntamento di questa serie.
Precisiamo subito che semplici regole possono essere scritte direttamente all'interno dei file di configurazione. All'interno dei plugin vanno messe regole più complesse o che si basano su dati che cambiano frequentemente.

Per prima cosa bisogna ereditare dalla classe base Plugin

package Mail::SpamAssassin::Plugin::MyPlugin;
use Mail::SpamAssassin::Plugin;
use DBI;
our @ISA = qw(Mail::SpamAssassin::Plugin);

sub new {
   my ($class, $mailsa) = @_;

   # the usual perlobj boilerplate to create a subclass object
   $class = ref($class) || $class;
   my $self = $class->SUPER::new($mailsa);
   bless ($self, $class);
 
   # add rule
   $self->register_eval_rule ("check_myplugin_header");
  
   return $self;                               
}

1;

In questo modo abbiamo registrato la nuova regola già definita all'interno del file di configurazione.

A questo punto bisogna dare corpo alla nuova regola che vogliamo introdurre nel tool.
Nel frammento di codice sopra abbiamo importanto anche le librerie DBI che ci consentono di interrogare il database con un comodo Object Model.

Facciamo un esempio di implementazione di una regola basata su DB.

sub check_myplugin_header
{
  
   my ($self, $pms) = @_;

   # Extract desidered informations from mail header   
   $head = $pms->get('CustomHeader');
  
   $result = 0;
   study;
  
   chomp($head);
   $head =~ s/;//;
  
   $dbh = DBI->connect("dbi:mysql:spamassassindb","user","pass");
  
  
   if(!defined $dbh)
   {
       die "Connessione al database non riuscita: $DBI::errstrn";
   }
  
   $query = "SELECT count(accepted_headers) FROM headers WHERE accepted_headers = $head";
  
   # Insert query into database instructions
   $sth = $dbh->prepare($query);
  
   # Database query execution
   $sth->execute;
  
   $count = $sth->fetchrow();

  
   if($count eq 0)
   {
       # Report error
       $result = 1;
   }

   # Disconnect from database
   $dbh->disconnect();

   return $result;
}

Questo frammento di codice è piuttosto semplice e fa una query al db, tramite DBI, dopo aver bonificato la stringa da passare.
Una cosa sicuramente da notare è il paramtro $pms che consente di accedere a tutti gli headers della mail.
Forniamo allora questo messaggio

From god@heaven.com  Thu Jun 17 21:33:41 2010
Return-Path: <god@heaven.com>
X-Original-To: account@post-server
Delivered-To: account@post-server
Received: from post-server (host [127.0.0.1])
   by post-server (Postfix) with SMTP id B66E9424F5
   for <account@post-server>; Thu, 30 Jun 2010 21:33:20 +0200 (CEST)
CustomHeader:blablabla
Subject:Try this

Simple mail to test my plugin.

a spamassassin e avremo due comportamenti diversi:

• Se la stringa "blablabla" è contenuta nel database la regola non andrà ad aggiungere i punti definiti nel file di configurazione (2.0 dal post precedente)
• Se la stringa "blablabla" non è contenuta allora la regola avrà un hit che sommerà 2 punti allo score totale. In questo secondo caso se questo punteggio fa superare la soglia (definita sempre nei vari file di configurazione) allora il messaggio verrà identificato come SPAM!!!

È un argomento piuttosto vasto che richiede tempo per essere assimilato. Questo è solo un input che vuole stimolare interesse. Spero di essere stato chiaro e sono a disposizione per un help in linea, per quanto posso fare.

Have fun ;)

How to write Spamassassin plugin - part 1

Sono giunto a un buon punto di un progetto per un esame universitario (che verrà pubblicato non appena consegnato) che riguarda un argomento sul quale ho trovato pochissimo materiale.

Si sta parlando della scrittura di un plugin che valuti una regola complessa su un messaggio e-mail, per determinare se si tratta di spam oppure no.

C'è voluto molto tempo per raggiungere qualcosa di funzionante ma ora che ho fra le mani un po' di codice che gira posso scrivere un articolo come questo e colmare la lacuna che il web mi ha mostrato. (I'll translate this article soon for international usage)

Cominciamo con installare tutto quello che serve (a parte una VM con sopra Ubuntu): Documentazione Ubuntu - Mail Server

A questo punto il plugin ha bisogno di due cose:

1. Un file di configurazione che permetta di richiamare la regola e le assegni un punteggio.
2. Una classe Perl che implementi l'interfaccia Plugin e che definisca precisamente la regola che si vuole aggiungere a Spamassassin.

In questa prima parte ci concentreremo sul file di configurazione. Nel prossimo articolo parleremo di come scrivere un .pm che interroghi un database per la valutazione di un header.

Il file di configurazione che bisogna comporre va depositato all'interno della directory di sistema /etc/spamassassin.
Possiamo andare a scriverlo direttamente con il seguente comando:

sudo gedit /etc/spamassassin/25_myplugin.cf

All'interno di questo file andiamo a scrivere due cose. La prima è il collegamento della funzione che andremo a definire nella nostra classe. La seconda è lo score che la regola aggiunge alla valutazione se si verifica la condizione definita.
Il contenuto sarà pressochè il seguente:

# Rule load for MyPlugin
header MY_RULE            eval:check_myplugin_header()
score MY_RULE 2.0

Per configurare la nostra personalizzazione manca solo un passaggio: bisogna far caricare a Spamassassin il nostro plugin. Va dunque cambiato un qualunque file *.pre. Apriamo quindi:

sudo gedit /etc/spamassassin/v310.pre

In coda a questo file vanno aggiunte le seguenti righe affinchè il nostro plugin venga caricato a successivo riavvio.

# load MyPlugin
loadplugin Mail::SpamAssassin::Plugin::MyPlugin

Conclusa la configurazione è il momento di scrivere il vero e proprio plugin ma sarà argomento del prossimo post.

Stay tuned ;)

Ah, quasi dimenticavo:

sudo /etc/init.d/postfix
sudo /etc/init.d/spamassassin

Google CL: una stupenda notizia!

Avevo già letto qualcosa nei giorni scorsi ma oggi un articolo dell'intramontabile Programmazione.it mi ha dato la certezza: Google ha fornito un set di strumenti da linea di comando per poter interagire tramite shell con i servizi che offre tramite il google-account.

Andando sul sito del progetto, rigorosamente googlecode, si possono individuare subito due cose.

La prima sono gli strumenti che è possibile utilizzare tramite linea di comando:

"We currently support the following Google services:
Blogger
$ google blogger post --title "foo" "command line posting"
Calendar
$ google calendar add "Lunch with Jim at noon tomorrow"
Contacts
$ google contacts list name,email > contacts.csv
Docs
$ google docs edit --title "Shopping list"
Picasa
$ google picasa create --title "Cat Photos" ~/photos/cats/*.jpg
Youtube
$ google youtube post --category Education killer_robots.avi"

Va aggiunto che sulla pagina principale del progetto è possibile anche trovare degli script di esempio che fanno capire meglio le potenzialità di questo strumento.

La seconda cosa che è possibile notare è il codice Python, liberamente consultabile (e ci mancherebbe altro, mi sento di aggiungere), che meglio ci può far comprendere l'utilizzo delle API e la duttilità di questo linguaggio di programmazione.

for i in {ls -l /home/myhome/pictures/} do echo i | google picasa post --title "My Photos"

;)

Google I|O: Una fucina di idee!

Ogni anno viene riproposto un evento. No, scusate, ogni anno viene riproposto L'Evento: il Google I|O, dove le menti più brillanti fanno vedere cosa si può fare con le moderne tecnologie a disposizione.



Una cosa in particolare ha catturato la mia attenzione. A questo link è possibile visionare un tech talk di quasi un'ora sul nuovo linguaggio di programmazione (Go-language). Questo talk è tenuto da Russ Cox, papà del linguaggio.

La particolarità di questa presentazione è il fatto che Russ si spinge in dettagli avanzati come la gestione degli oggetti e dei tipi che sicuramente hanno bisogno di chiarimenti da parte di chi ha concepito il linguaggio.

Ma i regali di G. non finiscono qua. Sul blog ufficiale della sezione code di Google è possibile guardare tutti i tech talk fra cui App Engine e Wave.

Buona visione a tutti ;)

Ubuntu 10.04 prime impressioni

Ho installato Ubuntu 10.04 (mannaggia non mi ricordo mai i nomi in codice delle varie release...) per processori a 64bit e mi trovo davanti a una Ubuntu box installata di fresco.

Dopo 3 upgrade di versione ho preso la decisione di installare questa LTS da zero per avere il nuovo file system ext4 e vedere come va.
Ecco quindi le primissime impressioni di questa release:

1. Il primo punto va sicuramente dedicato all'interfaccia grafica che è stata decisamente rinnovata e trova in questo rilascio una maturità che fin'ora era mancata. La discutibile scelta di mettere i pulsanti di gestione della finestra sulla sinistra della barra del titolo ha trovato una pronta spiegazione oggi. Sia che il tema scuro che il tema chiaro (molto OSX) danno uno stile moderno e distinto.
2. È vero non c'è più gimp, il messenger predefinito è empathy ecc ecc ecc ma io le trovo tutte scelte condivisibili e ragionevoli. Gimp si fa in un attimo a installare e Empathy trovo che sia un client buono, da esplorare, ma che mi ha già dato parecchie soddisfazioni.
3. La velocità complessiva del sistema mi sembra incrementata. L'unica cosa che pesa leggermente di più sulle prestazioni è Compiz. Con Compiz attivo le applicazioni che fanno uso intensivo della scheda grafica, come giochi e grafica 3d, ne risentono e tendono a scattare.

Parliamo invece dell'aria che si respira. Social, Cloud e Web sembrano le tre parole che hanno dettato la stesura di questa release. Oltre allo spostamento dei pulsanti di controllo si trovano di default e facilmente configurabili tutti gli strumenti per instant messaging. Empathy permette di comunicare con tutti i principali canali, da msn a facebook. Gwibber permette di aggiornare i propri contatti di social networking. Evolution da alle mail una nuova veste e rende calendario, mail e contatti integrati perfettamente all'interno del sistema. A tutto questo si unisce il servizio Ubuntu One, che già era presente nella versione 9.10, che garantisce quel tocco di cloud proprio di questi tempi.

Un'unica raccomandazione quindi: Get Ubuntu!

Nefarious-IDE, un primo passo dell'universo Go

A chi è stato molto attento non è per nulla nuovo, ma oramai mi sembra giunto alla maturità sufficiente per essere presentato a tutti.

Nefarious-IDE è un plug-in per Eclipse che ci permette di avere un IDE per il linguaggio GO che fino ad oggi abbiamo editato all'interno di scarni editor.

Il progetto non si può ancora definire avanzato ma quanto meno usabile. Infatti è già presente quasi tutta la parte di highlight della sintassi e permette di compilare i sorgenti scritti.

Ancora nulla sul versante autocompletamento o almeno suggerimenti ma sono sicuro che sia il primo punto sull'agenda dei dev.

Ecco lo stato di avanzamento delle varie parti:

"Current Features for Development Version: 0.0.12.a (Total Dev Time: 40.2 hrs)
- syntax highlighting (90%)
- compile upon save and mark errors within project (60%) (go compiler required)
- preference integration (70%)
- project configuration (65%)
- editor keyboard shortcuts (10%)
- go source to xml translator tool(65%)"

Sul sito ufficiale del progetto è possibile trovare l'url da inserire direttamente all'interno di Eclipse per scaricare il plug-in e automaticamente installarlo.

Buon divertimento ;)

Social networking e privacy

Scrivo raramente di questioni "filosofiche" relative al mondo dell'informatica ma oggi mi trovo a fare una riflessione sul fenomeno che da emergente è diventato abituale nella nostra vita: la partecipazione ai social network.

Ne parlo oggi in occasione delle sentenze dei tribunali che intimano a Google più privacy. Ne parlo oggi dove si parla molto di responsabilità delle compagnie che offrono i servizi e molto poco delle responsabilità degli utenti che utilizzano abitualmente (o meno) questi servizi.

Abbiamo assistito senza accorgercene a un decentramento delle responsabilità: gli utenti sono padroni della loro privacy e determinano in che misura gli altri utenti possono "farsi gli affari nostri". Lamentarsi successivamente perchè certe informazioni sono diffuse da solamente l'impressione che ci sia poca chiarezza su cosa sia il web.

Non troppo tempo fa (e anche oggi per quel che mi riguarda) ci si connetteva ad irc passando per un proxy che fosse il più sicuro e distante dalla nostra posizione geografica. Ci si mascherava dietro nick imperscrutabili. Si custodiva gelosamente la nostra identità.

Oggi non è più così e il web è diventato un estensione della nostra vita. Viene però troppo spesso confuso con la nostra vita e nei casi più estremi si sostituisce alla vita reale e qui scattano i problemi. L'audience è sterminato e il pericolo è di sentirsi in un reality perchè, diciamolo pure, a tutti i neo-internauti piace sentirsi nel Grande Fratello del giorno.

La cosa che vorrei vedere di più però è una responsabilizzazione degli utenti perchè ora la sicurezza verte su di loro. La privacy, o ciò che ne rimane, è nelle loro mani e poi non si deve e non si può piangere contro le compagnie che forniscono i servizi.

Spero di aver reso il più chiare possibili le mie idee con questo post. Con ciò non intendo asserire che le compagnie non hanno le loro responsabilità. Il vero problema è che stanno scivolando verso gli utenti.

Debian tricolore

Questa è una notizia che non può fare altro che inorgogliosirci:
Stefano Zacchiroli è stato eletto come Debian Project Leader.

È possibile consultare la sua pagina personale a questo indirizzo.

Ne tesse le lodi anche il Project Leader uscente, Steve McIntyre, che dichiara: "I've had a great time working for Debian as DPL and I'm more than happy to be handing over the reigns to Stefano. He has excellent ideas and should do a good job for us.".

Dall'articolo ufficiale emerge anche che Stefano è stato scelto fra un gruppo di candidati tra cui figura anche una donna: Margarita Manterola.

Chissà che un domani non ci sia una leadeship rosa per il progetto Debian.

Backtrack 4 - Live dal mio laptop

Il corso di laurea in sicurezza delle reti propone l'utilizzo di alcuni strumenti per l'analisi dei sistemi.

Gli strumenti sono tutti, o quasi, open source ma mi sono chiesto: "Perchè non installare una distribuzione che funzioni come una vera e propria cassetta degli attrezzi?". La risposta è stata BackTrack che nella sua quarta incarnazione racchiude il cuore di Ubuntu 8.10.

La uso da un paio d'ore e già mi trovo a mio agio. L'interfaccia grafica è kde3 e il sistema è molto più vicino al Linux nudo e crudo rispetto a Ubuntu ma la configurazione del sistema è stata molto semplice e tutte le periferiche, wi-fi incluso sono state riconosciute e funzionano correttamente.

All'interno dei menù di backtrack si trova tutto ciò che serve per testare le proprie reti, fare penetration testing e auditing: dal comunissimo nmap a openvas fino a brutessh. Ce n'è davvero per tutti i gusti e per tutte le esigenze.

Prossimamente cercherò di fare chiarezza su qualche strumento che si può trovare all'interno della distro ma per ora mi sento solo di fare un'entusiastica lode.

wait() in Go, How to?

Stamattina sono stato colto da un dubbio che ha fortunatamente trovato una risposta nella ricchissima mailing list di go-language: http://groups.google.com/group/golang-nuts?pli=1

La domanda che mi sono posto è la seguente: esiste un modo intelligente per aspettare che tutte le go routines abbiano finito la loro esecuzione prima di procedere alla chiusura della funzione main?

Stamattina, come al solito, apro le mail e trovo la seguente discussione.

Subito arrivano alcune risposte come ad esempio:

The standard practice in Go seems to be for goroutines to pass to a
channel so signal their end. For example:

package main

func routine(quit chan int) {
// do stuff
quit <- 1

}

func main() {
routineQuit := make(chan int)
go routine(routineQuit)

<-routineQuit // blocks until quit is written to

}

-Daniel

Ma poi arriva questo link che vi invito caldamente a seguire se siete interessati all'argomento come lo sono io perchè lo spiega in modo molto chiaro: link.

A breve altri approfondimenti.
Buon Go a tutti!

State Machine in Go-Language - 1^ parte

Comincia con questo articolo una serie di post che tratta un argomento molto attuale e utile. La vastità del mare nel quale ci apprestiamo a navigare avrebbe bisogno di molte e molte pagine di libro per questo ho deciso di spezzettare in più parti la trattazione.

L'utilizzo di macchine a stati mi sembra importante nella programmazione di sistema, soprattutto quando si parla di servizi.
Cosa succede allora quando le state machine incontrano Go?

Ma partiamo "dall'incomincio": ecco un esempio di macchina a stati semplicissima (e anche un po' inutile) che però fa capire in cosa consistono questi arcani.


Questo concetto è molto comodo quando si programma a oggetti. Come abbiamo visto nello scorso articolo il linguaggio Go possiede gli oggetti.
Creiamo dunque il nostro oggetto intorno allo stato interno che per comodità conterrà solo l'indice dello stato in cui ci troviamo.

type InternalState struct  {
    myState int;
}                          

Se prendiamo come modello quello nella figura sopra lo stato interno InternalState dovrà essere inizializzato, poi passare nello stato 1 e successivamente nello stato 2 prima di terminare.

Componiamo allora in questo modo la funzione che andrà a inizializzare la nostra macchina a stati:

func (state * InternalState) Init (inputValue int)
{
    state.myState = inputValue;
}

Avremo poi bisogno di due funzioni per ogni stato, una che effettua operazioni di entry ed exit:

func (state * InternalState) Stato1_Entry ()
{
}

func (state * InternalState) Stato1_Exit ()
{
}

func (state * InternalState) Stato2_Entry ()
{
}

func (state * InternalState) Stato2_Exit ()
{
}

Nel prossimo post vedremo invece come unire tutti i componenti appena creati per far transitare lo stato dell'oggetto da quello iniziale a quello finale passando per gli stati intermedi.

Spero inoltre di aver messo qualche pulce nell'orecchio per approfondire un argomento veramente interessante.

OOp in go-lang

Prima di cominciare a parlare dell'argomento di questo post consentitemi di fare un piccolo festeggiamento per il 200esimo post su questo blog. Ultimamente ho rallentato la frequenza di aggiornamenti ma spero di averne incrementato la qualità.

Penso che una caratteristica che ha fatto storcere il naso a molti sia l'assenza della keyword class nel linguaggio Go.
In un primo momento questa illustre assenza potrebbe far pensare all'assenza del concetto di oggetto che invece è molto presente e molto utile.

Ma andiamo in ordine:

1) Definizione di nuovi tipi
Go permette di definire nuovi tipi con la keyword type.

type File struct  {
  fileName [] byte;  //Name of the file
  sizeInByte int;    //Size of the file
  path [] byte;      //Location of the file on hd
}

In questo modo abbiamo associato alla struttura File un nuovo tipo che da ora in avanti avrà gli attributi descritti all'interno.

2) Definizione di nuovi metodi
Creare nuovi metodi che eseguano del codice è molto semplice.

func PrintAll()
{
    fmt.Printf("All");
}

3) Associare i metodi ai tipi
A questo punto perchè non provare ad associare il metodo PrintAll al tipo File in modo che stampi tutti gli attributi di File quando viene invocato?
Si deve quindi dire al metodo PrintAll che eseguerà operazioni solo sul tipo File.

func (f * File) PrintAll()
{
  fmt.Printf("Filename: %s\n",f.fileName);
  fmt.Printf("Size: %d\n",f.sizeInByte);
  fmt.Printf("Path: %s\n",f.path);
}

4) Istanziare un nuovo File
In questo modo si potrà dunque istanziare un nuovo oggetto di tipo file e invocarne il suo metodo.

filePtr := new(File); //File *
filePtr.fileName = "Useless.txt";
filePtr.sizeInByte = "1024";
filePtr.path = "$HOME";

//Call File method
filePtr.PrintAll();

------------------------------------------------------

L'argomento è ovviamente molto più esteso ma in questo post volevo dare soltanto un'introduzione all'utilizzo degli oggetti all'interno di Go per i più scettici.
Prossimamente potremo anche parlare di Interfacce lasciando però prima di addentrarci tutti i preconcetti che arrivano da altri tipi di linguaggi poichè Go affronta tali argomenti da un altro punto di vista.

Ma in Italia c'è internet?

Sapevate che esiste un Google Lab? ... Si? ... Bene!
Sapevate che il Google Lab ha organizzato un tour in giro per il mondo? È proprio una gran figata!!!
Sapevate che Google ha pensato bene di non includere l'Italia nel tour?

Ebbene si, Google, come è accaduto per l'Android Developer Challenge, ha ritenuto che l'Italia non è degna di certi riguardi. Prima però di scagliarsi contro la multinazionale di turno io mi fermerei un attimo a riflettere e guardare in faccia la realtà di ciò che il nostro paese fa nell'era del Web 2.0.

Le infrastrutture sono quelle che sono. Internet sui cellulari lo usa il 2% (stima mia personale fatta ad occhio con una certa ironia) della popolazione e quasi nessuno sa cosa vuol dire cloud.
Vi sembra normale? A me personalmente no! Direi che è giunto il momento di darsi una bella svegliata se non vogliamo rimanere indietro per sempre.

Detto questo Google non ci fa sicuramente una bella figura visto che per quanto riguarda la telefonia l'Italia ha sicuramente un mercato redditizio pari a quello degli altri paesi. Purtroppo è sul piano dei servizi che deficitiamo.

Parametri da linea di comando secondo Go

Go-lang è stato pensato per essere il linguaggio definitivo per le applicazioni di sistema.
Una delle cose che più impreziosiscono gli strumenti che (non) tutti i giorni utilizziamo per l'amministrazione del nostro sistema è sicuramente il parco di opzioni e flag che possiamo indicare da linea di comando.

Go-lang permette molto comodamente di dichiarare quali saranno i parametri che ci aspettiamo di ricevere da linea di comando, di che tipo saranno e che cosa comunicare all'operatore per aiutarlo nell'utilizzo del tool.

Vediamo, con un semplice esempio, ciò che Go ci mette a disposizione per rendere la nostra applicazione il più flessibile possibile.

Cominciamo con dichiarare quali flag ci aspetteremo:

//Flags
var file_to_download * string;
var fileType * string;
var configShow * string;
var configEdit * bool;

Successivamente definiamo le keywords con le quali potranno essere attivati i parametri:

/**
 *Function used to initialize flags from command line.
 */
func initFlags() int
{
  file_to_download = flag.String("d","","Type the name of the file");
  fileType = flag.String("t","*","Kind of file you want to download:\n\t*: all\n\tmov: movie\n\tmsc: music");
  configShow = flag.String("c","editor","Open the config file into chosen [editor]");
  configEdit = flag.Bool("C",false,"Edit parameters of config from inside the program.");
}

Il package flag contiene una funzione di definizione parametro per ogni tipo di comando che desideriamo ricevere. Tutte queste funzioni però hanno tutte la stessa forma. Ricevono infatti tre parametri:

1. La lettera/Le lettere che identificano il comando;


2. Il comportamento di default;


3. Un messaggio da dare all'operatore su come va utilizzato il flag.

Una volta definiti i flag possiamo utilizzare i comandi che arrivano dalla shell all'interno del nostro programma:

/**
 *Main function. From here the program starts.
 */
func main()
{

  //Initialize flags
  initFlags();

  flag.Parse(); //Scans the arg list and sets up flags

  var fileStr string = "";
  var typeStr string = "";
  var confStr string = "";
  var confMode bool = false;

  confStr += *configShow;
  confMode = *configEdit;
  
  if(confMode)
  {
    os.Stdout.WriteString("Config mode\n");
  }
  else
  {
    os.Stdout.WriteString("Normal mode\n");
  }

  if( *file_to_download == "") //Want to download a file
  {
    fileStr += "errore";
    fileStr += Newline;
    os.Stdout.WriteString(fileStr);
  }
  else
  {
    fileStr += *file_to_download;
    fileStr += Newline;
    os.Stdout.WriteString(fileStr);
  }

  typeStr += *fileType;
  typeStr += Newline;
  os.Stdout.WriteString(typeStr);

  //Useless calls
  giogolib.LogMessage(def.Debug,"Applicazione partita");
}

Spero di aver mostrato in modo chiaro come Go lang permetta di fornire all'utente che andrà ad utilizzare la nostra applicazione tutti gli strumenti per adattare l'esecuzione del software alle sue esigenze.

Gennaio bollente!

Dopo una breve e meritatissima vacanza passata sul suolo parigino si ricomincia con la nostra battaglia per la libertà nel software (e non solo).

Lo stato italiano finalmente ci da uno strumento importante che è la class action. Sicuramente questo strumento si andrà ad affinare ma già al giorno d'oggi ci consente di battagliare per avere dei computer senza Windows pre installato. In questo modo l'utente sarà libero di scegliere quale sistema operativo e suite da lavoro installare.

Per approfondire questo interessante argomento vi consiglio di dare una sbirciatina a ossblog.it che ha un articolo veramente ben fatto ;)