Andrea Francia's Blog

Hacking di un Hard disk di rete

2012-01-09T00:13:00.000+01:00

Problema

In questi giorni sono tornato a smanettare con il mio My Book World Edition.
Lo vendono come "Harddisk di rete", in realtà è un NAS (Network Attached Storage) cioè un computer con un grosso disco, una scheda di rete e tutto il software necessario per condividere il proprio disco con gli altri PC della LAN. Questo NAS, come molti altri dispositivi con computer integrato, nasconde al suo interno un sistema operativo Linux processore ARM.
La distribuzione Linux usata è una versione proprietaria e soprattutto minimale. Mancano comandi quasi indispensabili come screen, le utility di base sono limitate (ad esempio rm non ha l'opzione -v), manca il Vim e in generale non è possibile aggiungere nuovo software.
Per queste distribuzioni senza un proprio package manager e che girano su ARM il modo più semplice per installare software è quello di usare optware.
In teoria dopo aver seguito le istruzioni di installazione esso dovrebbe permettere di installare i nuovi pacchetti con:

ipkg install <nome-pachetto>

Per installare optware basta seguire la guida su mybookworld.wikidot.com dove è anche spiegato come accedere alla shell del NAS tramite SSH. Qui finisce la teoria e inizia la pratica perché a casa mia c'é un problema che non mi permettere di sfruttare questo utile programma: il NAS non può accedere ad Internet! Di conseguenza ipkg non potrebbe scaricare nessun pacchetto! Infatti a casa non ho l'ADSL e l'unico modo che ho per accedere alla Rete è la chiavetta Internet :-(
Improbabili cablaggi e riconfigurazioni della tabella di routing sono fuori discussione. Si tratta di un problema soft, il mio portatile può accedere ad Internet e può accedere al NAS, quindi la soluzione deve essere soft.

Soluzione

La soluzione soft si basa sui web proxy e sui tunnel SSH e si compone di due passi: 1. installo sul mio portatile un web proxy 2. faccio in modo che ipkg usi il web proxy del portatile
Ho deciso di installare polipo, un web proxy mono-thread che sembra più semplice del pidi squid::

(portatile) $ brew install polipo
(portatile) $ polipo
Established listening socket on port 8123.
...

Ora il proxy si trova in ascolto sulla porta 8123 del mio portatile; con il port-forwarding di SSH posso fare in modo che sia accessibile anche dal mio NAS::

(portatile) $ ssh -R8123:localhost:8123 nas.local

Però non so come configurare ipkg in modo che usi il proxy giusto. Fa niente, lo posso scoprire con un avvio di prova::

(nas) ~ # ipkg install nano     
Installing nano (2.2.6-1) to root...
Downloading http://ipkg.nslu2-linux.org/feeds/optware/cs05q1armel/cross/unstable/nano_2.2.6-1_arm.ipk
Nothing to be done
An error ocurred, return value: 22.
Collected errors:
ipkg_download: ERROR: Command failed with return value 1: `wget --passive-ftp

-q -P /opt/ipkg-ZFXnou http://ipkg.nslu2-linux.org/feeds/optware/cs05q1armel/cross/unstable/nano_2.2.6-1_arm.ipk'
Failed to download nano. Perhaps you need to run 'ipkg update'?

Dal messaggio di errore appare chiaro che ipkg usi wget come backend per il download, quindi mi dovrebbe bastare configurare quello::

(nas) ~ # cat >> ~/.wgetrc << EOF
http_proxy = http://localhost:8123/
use_proxy = on
EOF

E in effetti funziona::

~ # ipkg install nano
Installing nano (2.2.6-1) to root...
Downloading http://ipkg.nslu2-linux.org/feeds/optware/cs05q1armel/cross/unstable/nano_2.2.6-1_arm.ipk
Configuring nano
Successfully terminated.

Moving to ZSH

2011-11-09T20:27:00.003+01:00

In those days I decided to adopt Zsh as my working shell instead of Bash. I don't know yet whether Zsh will be a better shell for my purposes but I decided to give it a try.

Up to now I found these interesting things:
Better man pages:

Bash has a big single man page that explains every facet of the shell. Zsh man pages are split out in a few pages, each one of a more manageable size. The bash(1) man page uses a very prescriptive tone in describing the behaviour of the program, reading the bash man page is more like reading a technical specification than a user manual. The zsh man pages are more geared towards the final user.

Support for colors even in completion suggestions

Command completion is the thing I always loved in Bash. Zsh goes one step further, it supports completion and even colors in completion.

More support for the prompt customization
Zsh provides out-of-the-box some features than in Bash can be only emulated, for example you can define also a right-side prompt that will be drawn along side the normal prompt on the left.

Configuration wizard for new users

New users can use the configuration wizard that will create the configuration file (.zshrc) according with their preferences.

svn-repair-move

2011-10-04T23:00:00.000+02:00

Subversion does not detect moves as other version control system does. This could be a problem when you rename or move a file not using the appropriate subversion command.
For example, if you rename a file named "foo" to "bar" without using the Subversion command, it shows "foo" as "missing"and bar as "non-versioned":


$ svn status
?       bar
!       foo

While TortoiseSVN has it's own "Repair move..." feature, from the command line perspective I had had to fix this manually until I wrote a simple script that handles this situation.
It works like that:


$ svn-repair-move foo bar
$ svn status
D       foo
A  +    bar

Come aggiungere un custom task a setup.py

2011-07-26T22:00:00.000+02:00

Per avere questo comportamento:

 $ python setup.py foo
 running foo
 foo ... foo ... foo!

Si fa così:

from setuptools import setup, Command                                          
                                                                               
def main():                                                                    
    setup(                                                                     
        cmdclass={'foo':FooCommand}                                            
    )                                                                          
                                                                               
class FooCommand(Command):                                                                                                                                                    
    description="Does foo-ish things."                                         
    user_options=[]                                                            
    def initialize_options(self): pass                                         
    def finalize_options(self): pass                                           
    def run(self): print("foo ... foo ... foo!")                               
                                                                               
main()

Writing a Crawler with Python and TDD (slide disponibili)

2011-07-21T13:43:00.001+02:00

Ieri ho partecipato al meeting XPUG di Milano dove ho presentato il mio ultimo lavoro.
Su slideshare trovate le diapositive che ho usato.

Mock Object in Python

2011-05-10T22:09:00.001+02:00

Uno dei problemi che ho quando sviluppo in Python e' che non ho ancora trovato una libreria di mocking che mi soddisfi. Non che non ci sia scelta, ci sono almeno tre librerie, peccato che ognuna abbia qualcosa che non mi va. Ieri, mentre stavo scrivendo dei test per trash-cli, ho scritto una classe Mock ex-novo adatta alle mie esigenze. L'esempio di utilizzo e' il seguente:

from double import Double

fs=Double('fs')
fs.on_method('volume_of').will_reply('/')
fs.on_method('exists').with_args('/.Trash').will_reply(True)
fs.on_method('has_sticky_bit').with_args('/.Trash').will_reply(True)

La classe è questa:

class Double:
    def __init__(self, name):
        self.name = name
        self.expectations = {}
        self.expectations_with_args = {}
    def __getattr__(self, name):
        if name in self.expectations:
            def fake_method(*args, **kwargs):
                return self.expectations[name]
            return fake_method
        else:
            def fake_method(*args, **kwargs):
                if (name, args) in self.expectations_with_args.keys():
                    return self.expectations_with_args[(name,args)]
                self._report_unexpected_call(name, *args, **kwargs)
            return fake_method
    def __call__(self, *args, **kwargs):
        self._report_unexpected_call(self.name, args, kwargs)
    def on_method(self,name):
        class Expectation:
            def will_reply(_, return_value):
                self.expectations[name] = return_value
            def with_args(_,*args):
                class Expectation2:
                    def will_reply(_, return_value):
                        self.expectations_with_args[(name,args)] = return_value
                return Expectation2()
        return Expectation()
    def _report_unexpected_call(self, method_name, *args, **kwargs):
        assert False, ("Unexpected call: %s(%s,%s)" % ( method_name,
                     ','.join(repr(arg) for arg in args),
                     ','.join('%s=%s' %(key,value) for key, value in
                         kwargs))
                     + "Calls expected:%s and %s " %
                     (self.expectations,
                         self.expectations_with_args))

Si tratta di una soluzione quick and dirty, molto dirty. Nonostante sia dirty ha un suo valore. Scrivendola ho imparato che scrivere una classe di Mock non richiede molto tempo e ora so che potrebbe volerci meno tempo a scrivere un Mock in Python rispetto a trovare la libreria di mocking giusta tra quelle disponibili in rete.
Credo che questo dipenda essenzialmente dal fatto che Python e' un linguaggio dinamico e che di conseguenza offre costrutti molto piu' semplici per fare metaprogramming rispetto ad altri linguaggi con tipizzazione piu' statica.

Submit an HTML form using POST method via Java

2010-09-04T15:14:00.000+02:00

In the recent days I'm studying how to implement HTTP/REST architecture in Java.
I decided to work without any REST framework, so nothing like Jersey or restlet. Instead I decided to exploit the good old Servlet API which seems to use an faithful model on how the HTTP works.

And also I decided to starts from study how to design Web applications in a way that uses correctly the HTTP protocol.

During my study I didn't find a HTTP client which fit my requirements so I'm writing some client functionalities from scratch. This is the way I implemented the posting of a form with only one parameter:

private static InputStream postForm(final String url,
     final String paramName,
     final String paramValue) throws IOException
    {
 return new Object() {

     public InputStream postForm() throws IOException {
  prepareConnectionToServer();
  packageFormValuesInAMessage();
  submitTheMessage();
  return theServerReply();
     }

     private void prepareConnectionToServer() throws IOException {
  connection = new URL(url).openConnection();
  connection.setDoInput(true);
  connection.setDoOutput(true);
  connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
     }

     private URLConnection connection;

     private void packageFormValuesInAMessage() throws UnsupportedEncodingException {
  message = String.format("%s=%s", paramName, URLEncoder.encode(paramValue, "UTF-8"));
     }

     private String message;

     private void submitTheMessage() throws IOException {
  OutputStream output = connection.getOutputStream();
  output.write(message.getBytes("UTF-8"));
  output.close();
     }

     private InputStream theServerReply() throws IOException {
  return connection.getInputStream();
     }

 }.postForm();
    }

Povero modello a cascata

2010-08-25T19:53:00.000+02:00

Tutti se la prendono con il modello di sviluppo software a cascata.

Da un certo punto di vista fanno bene perché è una soluzione che ha diversi difetti, come ad esempio il fatto che non consente di utilizzare la esperienza e la conoscenze acquisite nel corso del progetto.

Però, nonostante questo, ci sono dei pregi che gli vanno riconosciuti. Non tanto perché lui si offenda (è un modello non può offendersi!) ma il rischio è sempre quello di gettare via il bambino con l'acqua sporca.

Sono stato quindi contento di leggere questo post dove Peter Stevens ne sottolinea i principi (cito letteralmente):

Waterfall says:
1. Figure out the business requirements first
2. Don't change your requirements while you are implementing
3. Test your code to ensure that it works

Se ci pensate bene sono gli stessi principi (che dovrebbero essere) applicati quando si usa Scrum, XP, o TDD, l'unica (grande) differenza è la scala temporale.

Il Mac OS X

2010-07-03T15:28:00.002+02:00

Il Mac OS X è unico ed avvicente.

Unisce in modo unico i difetti di Windows a con quelli di Linux e, non contento, aggiunge qualcosa di speciale che fa solo lui. Il magico effetto mac!

Risultato? Non c'e' il taglia e incolla dei file. Non puoi fare copia path della cartella che stai visualizzando. Il cestino non si ricorda la data di cancellazione e la posizione originale. Non c'e' un sistema a pacchetti unico. È possibile avere tre diverse versioni di Ruby (o Python) e non saperlo (macruby, ruby su macports, ruby su fink).

Il mac aiuta ad esercitare la mente. Su linux è quasi banale usare 'ls --color', 'ls --sort=time'. Gli utenti mac hanno più memoria ed usano 'ls -G' e 'ls -t'. Sapete come risponde il mac alla frase 'ls --help'? Così:

[andreafrancia@deneb ~]$ ls --help
/bin/ls: illegal option -- -
usage: ls [-ABCFGHLOPRSTUWabcdefghiklmnopqrstuwx1] [file ...]

Sono proprio belle le utility BSD!

Gabriele Lana sui Code Kata al #codingdojo

2010-06-19T10:27:00.001+02:00

Il quick & dirty è "quick" perché è "dirty"?

Secondo Gabriele Il "quick" é quick perché siamo abituato a farlo.

Da dove viene il talento? Viene dalla genetica o dall'ambiente? Cos'è la pratica profonda?
Cosa sono i code kata?

Gabriele illustra come si è scoperto che la pratica profonda sia il vero e unico fattore comune tra le persone riconosciute di talento e spiega come applicare questa "scoperta" alla nostre performance nello sviluppo software.

Writing automatic tests using bash

2010-06-11T23:26:00.000+02:00

This may be not well know but the bash shell could also be used to write automatic test. These tests could be also used with Hudson which recognizes if they are failed or not.

This is a little integration test for a legacy application:

set -o errexit     # this tell bash to stop on any error
set -o xtrace      # this tell bash to print any command before execution

# setup the database
mysql -u root test-database << EOF
    DELETE FROM orders_to_be_exported;
    INSERT INTO orders_to_be_exported(id) VALUES('1235');
    DELETE FROM order;
    INSERT INTO order(customer_name, amount) VALUES('andrea', '1234');
EOF

# clean up filesystem
rm /tmp/orders/exported-*.order -f

# start up the application
mvn jetty:run

curl -X POST http://localhost:8080/application/export-orders

test -f /tmp/exported-1235.order  # this check if the file exists

# the following checks the contents of the file
diff /tmp/exported-1235.order - << EOF
Customer: Andrea
Amount: 1234 eur
EOF

Whenever this script fail in any of its operation it stops with an non zero exit code. This is because the set -o errexit instruction. As you may known a non zero exit status often means that an error has been occured. Also Hudson knows this and when this happen it marks the build as broken.
The set -o xtrace instructions tell to bash to write each command before executing it.

This script demonstrate clearly how powerfull could be the shell, you can

invoke ReST web services (with curl)
inspect the contents of a file (with diff)
test for the existence of a file (with test -f), a directory (test -d), and many others facts about your filesystem
interact with the database

As you know these kind of test (integration tests) are slow and when they fails is difficult to know which component is broken. Nevertheless they are a essential to know if yours unit are playing well together.
They may be also useful when you work with legacy code. You may want to put some part of the system under unit test but can't do that before of many refactoring. You could create an integration test, refactor the code toward a better modularity and then place the unit test and, maybe, delete the integration test.

How to download from jars from mavencentral with Ant without Ivy

2010-04-29T21:20:00.001+02:00

For my Ant projects I want download the dependencies from the maven repository without converting it to maven.

I solved putting this "build.xml" in the "lib" directory:

<project name="lib" default="download-libs" 
         xmlns:artifact="urn:maven-artifact-ant">

  <property name="maven.ant.tasks.jar" value="maven-ant-tasks-2.1.0.jar" />

  <target name="download-libs" depends="-init-maven-task">
    <artifact:dependencies pathId="dependencies.classpath">
      <dependency groupId="org.codehaus.groovy" 
                      artifactId="groovy" version="1.7.2" /> 
      <dependency groupId="org.ccil.cowan.tagsoup" 
                      artifactId="tagsoup" version="1.2" />

      <remoteRepository id="maven-central" 
                      url="http://repo1.maven.org/maven2/" />
    </artifact:dependencies>

    <move todir=".">
      <path refid="dependencies.classpath"/>
    </move>
  </target>

  <target name="-init-maven-task" depends="-obtain-maven-task-jar">
    <available property="maven.ant.tasks.jar.exists" 
               file="${maven.ant.tasks.jar}" />
    <typedef resource="org/apache/maven/artifact/ant/antlib.xml" 
             uri="urn:maven-artifact-ant" classpath="${maven.ant.tasks.jar}" /> 
  </target>

  <target name="-obtain-maven-task-jar">
    <available property="maven.ant.tasks.jar.exists" 
               file="${maven.ant.tasks.jar}" />
    <antcall target="download-maven-jar"/>
  </target>

  <target name="download-maven-jar" unless="maven.ant.tasks.jar.exists">
    <property name="maven.ant.tasks.url" 
              value="http://www.apache.org/dist/maven/binaries/${maven.ant.tasks.jar}" />
    <get src="${maven.ant.tasks.url}" dest="${maven.ant.tasks.jar}" />
  </target>

</project>

To download libs just type:

$ cd lib

$ ant

...

and all dependencies will be downloaded.

Presentazione su Google C++ Testing Framework e Visual Studio 2008 all'XPUG di Milano

2010-04-15T01:32:00.004+02:00

Sono appena tornato dal meeting XPUG di Milano dove ho presentato come usare Google Test in Visual Studio 2008. Le slides usate sono già disponibile su slideshare.

Tutorial Google Test

2010-04-01T20:56:00.001+02:00

Google Test è un framework di test per C++. In questa miniguida spiego come usarlo in Visual Studio 2008. Per seguire la guida non avete bisogno di conoscere Visual Studio 2008, dovete però avere un idea di cosa sia un framework xUnit, e dovete conoscere C o C++.

Scaricare e installare Google Test

Scarichiamo dal sito ufficiale l'ultima release, ad oggi il file gtest-1.4.0.zip e lo decompriamo, per esempio in c:\gtest-1.4.0.

Google Test supporta diversi compilatori tra cui fortunatamene Visual Studio 2008. I progetti di Visual Studio si chiamano “Soluzioni”, dentro la cartella C:\gtest-1.4.0\msvc ci sono due soluzioni:

· gtest.sln (da usare se volete linkare staticamente la libreria gtest,come .LIB)

· gtest-md.sln (da usare se volete linkare dinamicamente la libreria, come DLL).

Potete scegliere di usare sia uno che l’altro, io per semplicità io scelgo di usare la libreria statica.

Prima di aprire la soluzione togliete però l’eventuale flag “read only” da tutti i file dentro msvc. Se non lo fate ve ne pentirete J. Quando gtest.sln con Visual Studio 2008 vi chiederà di aggiornare la soluzione al nuovo formato, ditegli di sì con il solito Avanti, Avanti, Avanti. Se non avete tolto il readonly il Visual Studio si lamenterà.

Una volta apete provvede alla build di tutta la soluzione con F7 (Build > Build Solution).

Se tutto va bene dovrebbe crearvi i file gtest_maind.lib e gtestd.lib in C:\gtest-1.4.0\msvc\gtest\Debug.

Il primo progetto Visual Studio

Se siete pratici di Visual Studio saltate pure al prossimo paragrafo. Se come me non siete pratici seguitelo.

Creiamo il primo progetto di test, daVisual Studio scegliamo:

File > New > New Project

e scegliamo “Win32 Console Application”. Diamo al progetto un nome qualsiasi, io ho usato "LearningGoogleTest". Se il wizard ve lo chiede, sappiate che le "Precompiled Header" non vi servono.

Il risultato dovrebbe essere simile a questo:

I file stdafx.h, stdafx.cpp, targetver.h sono creati gratuitamente dal Visual Studio e per i miei scopi non valgono lo spazio che occupano, quindi io li cancello.

Dato che non sono pratico di Visual Studio prima di procedere oltre provo con un Hello World:

// LearningGoogleTest.cpp

#include <stdio.h>

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

printf("Hello world!\n");

return 0;

}

Con CTRL+F5 (Debug > Start Without Debugging) possiamo ammirare la nostra creazione:

Notate quanto sia gentile Visual Studio 2008 a chiedervi di schiaccciare un tasto prima di chiudere la finestra, Visual Studio 6.0 non era così simpatico.

Aggiungiamo la libreria Google Test al nostro progetto

Le librerie C/C++ sono una scocciatura perché per poterle usare devi sistemare due cose:

· i path dei file header (.h)

· i path dei file di libreria (.dll o .lib)

Io preferisco affrontare questi problemi uno alla volta.

Sistemare i path degli headers

Includiamo l'header di gtest in “LearningGoogleTest.cpp”:

// LearningGoogleTest.cpp

#include <stdio.h>

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

printf("Hello world!\n");

return 0;

}

// LearningGoogleTest.cpp

#include <stdio.h>

#include <gtest/gtest.h>

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

printf("Hello world!\n");

return 0;

}

Compiliamo (F7) e notiamo l’errore:

learninggoogletest.cpp(4) : warning C4627: '#include <gtest/gtest.h>': skipped when looking for precompiled header use

Risolviamo aggiungendo in

Project Settings > Configuration Properties > C/C++ > Additional Include Directories

il path (completo) di gtest-1.4.0\include

Tentiamo di nuovo ed ora abbiamo un errore durante la fase di linking:

Risolviamo aggiungendo in

Project Settings > Configuration Properties > Linker > Input > Additional Dependencies

i path di queste due librerie

· "c:\gtest-1.4.0\msvc\gtest\Debug\gtest_maind.lib"

· "c:\gtest-1.4.0\msvc\gtest\Debug\gtestd.lib"

Mi raccomando di usare i doppi apici (") se ci sono spazi nei path!

In teoria farlo ora dovrebbe funzionare ma in pratica no! Se anche voi avete errori del genere:

allora vuol dire che lo switch Runtime Library usato per il progetto gtest.sln e quello del vostro progetto non coincidono.

Per risolvere andate in:

Project Settings > Configuration Properties > C/C++ > Code Generation > Runtime Library

E assicuratevi che ci sia:

Multi-threaded Debug (/MTd)

A questo punto la build dovrebbe andare a buon fine.

Eseguire i test

A questo punto dovremmo avere a disposizione tutto l’occorrente per scrivere, compilare ed eseguire i test.

Riprendiamo il file LearningGoogleTest.cpp e togliamo la funzione main().

// LearningGoogleTest.cpp

#include <stdio.h>

#include <gtest/gtest.h>

TEST(foo,bar) {

FAIL();

}

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

~~printf("Hello world!\n"~~);

~~return~~ 0;

}

// LearningGoogleTest.cpp

#include <stdio.h>

#include <gtest/gtest.h>

TEST(foo,bar) {

FAIL();

}

In questo modo il linker andrà a prendere la main() da gtest_maind.lib la quale fa esattamente quello che ci serve: esegue tutti i test.

Premendo CTRL+F5 il programma si avvia e vengono eseguiti tutti i test. Il risultato dovrebbe essere questo:

Abbiamo un solo test e questo non passa ... per forza 0 non è uguale a 1!

Facciamo passare il test:

// LearningGoogleTest.cpp

#include <stdio.h>

#include <gtest/gtest.h>

TEST(foo,bar) {

ASSERT_EQ(0,1);

}

// LearningGoogleTest.cpp

#include <stdio.h>

#include <gtest/gtest.h>

TEST(foo,bar) {

ASSERT_EQ(1,1);

}

E con CTRL+F5 otteniamo la prima barra verde:

Integrazione in Visual C++

I messaggi di FAIL di gtest sono Visual Studio friendly. Ora vediamo come sfruttare questa feature.

Con il Post-Build Event diciamo Visual Studio di avviare i test dopo ogni build.

Per farlo impostiamo in

Project Settings > Configuration Properties > Build Events > Post-Build Event > Command Line

il valore:

"$(TargetDir)\$(TargetName).exe"

Ora, se avviamo la build (F7) dovrebbe ritrovarci i risultati dei test nella finestra Output. Ma non è finita qui. Simuliamo un fallimento nel nostro test:

// LearningGoogleTest.cpp

#include <stdio.h>

#include <gtest/gtest.h>

TEST(foo,bar) {

ASSERT_EQ(1,1);

}

// LearningGoogleTest.cpp

#include <stdio.h>

#include <gtest/gtest.h>

TEST(foo,bar) {

ASSERT_EQ(0,1);

}

Avviamo la build (F7) e otteniamo qualcosa del tipo:

Cliccando sul messaggio di errore il Visual Studio ci porta alla linea che l’ha provocato.

Understanding the output of rsync --itemize-changes

2010-03-06T18:05:00.003+01:00

As you may know the rsync's --delete options if misused could make severe damage.

To prevent this you can use the --itemize-change and the --dry-run options to figure out how the command will behave before launching the real one.

The output will be something like that:

.d..t..g... ./
.f...p.g... Something.pdf
.f.....g... md5sum-2010-02-21.txt
.f...p.g... prova.rb
.d.....g... .metadata/
.f...p.g... .metadata/.lock
.f...p.g... .metadata/.log
.f...p.g... .metadata/version.ini
>f+++++++++ Parameter_Usage.txt

Where the first field of each line tell what rsync would do to each file.

I wrote this little schema that helped me to understand this output format and I'm publishing hoping it will be useful for others.

YXcstpoguax  path/to/file
|||||||||||
`----------- the type of update being done::
 ||||||||||   <: file is being transferred to the remote host (sent).
 ||||||||||   >: file is being transferred to the local host (received).
 ||||||||||   c: local change/creation for the item, such as:
 ||||||||||      - the creation of a directory
 ||||||||||      - the changing of a symlink,
 ||||||||||      - etc.
 ||||||||||   h: the item is a hard link to another item (requires --hard-links).
 ||||||||||   .: the item is not being updated (though it might have attributes that are being modified).
 ||||||||||   *: means that the rest of the itemized-output area contains a message (e.g. "deleting").
 ||||||||||
 `---------- the file type:
  |||||||||   f for a file,
  |||||||||   d for a directory,
  |||||||||   L for a symlink,
  |||||||||   D for a device,
  |||||||||   S for a special file (e.g. named sockets and fifos).
  |||||||||
  `--------- c: different checksum (for regular files)
   ||||||||     changed value (for symlink, device, and special file)
   `-------- s: Size is different
    `------- t: Modification time is different
     `------ p: Permission are different
      `----- o: Owner is different
       `---- g: Group is different
        `--- u: The u slot is reserved for future use.
         `-- a: The ACL information changed

This schema is based on the contents of the rsync manual.

Presentazione sul Single Responsibility Principle

2010-02-27T21:25:00.007+01:00

Oggi sono stato in svizzera all'AgileCamp ospitato da sketchin. Ho trovato tutti gli interventi interessanti, e ... ho presentato anch'io!

L'argomento che ho trattato è il "Single Responsibility Principle", la S di SOLID.

Le slide sono già su slideshare.

Applicazioni REST standalone (senza Tomcat o Glasshfish)

2010-02-10T21:00:00.001+01:00

Ho cercato di capire come sia possibile avviare Jersey in modalità standalone, cioè senza dover ricorrere ad inutili (per ora) complessità, come:

application servers (e.g. Glasshfish)
web containers (e.g. Tomcat)
sistemi di build lenti e complicati (e.g.maven)

Inoltre non volevo avere tra i piedi un file "web.xml".

Ho scoperto che è possibile! La documentazione non è facile da trovare, sembra quasi che Oracle (ex Sun) spinga per complicarti la vita.

Se volete provare anche voi dovete prima di tutto procurarvi le librerie necessarie:

grizzly-servlet-webserver-1.9.18-e.jar
asm-3.1.jar
jersey-core-1.1.5.jar
jersey-server-1.1.5.jar
jsr311-api-1.1.1.jar

La prima contiene Grizzly (un embeddeddable web server), le restanti fanno parte della distribuzione di jersey e sono scaricabili in un unica soluzione: jersey-archive-1.1.5.zip

Una volta aggiunte le librerie al progetto potete passare alla creazione della risorsa di esempio:

// file Hello.java
package learn.jersey.grizzly;
import javax.ws.rs.*;

@Path("/hello")
public class Hello {
    @GET @Produces("text/plain")
    public String sayHello() {
        return "Hello World!";
    }
}

E infine il main (che è cortissimo!):

// Main.java
package learn.jersey.grizzly;

import com.sun.grizzly.tcp.Adapter;
import com.sun.jersey.api.container.ContainerFactory;
import com.sun.jersey.api.container.grizzly.GrizzlyServerFactory;
import java.io.IOException;

public class Main {

    public static void main(String[] args) throws IOException {
        Adapter adapter = ContainerFactory.createContainer(Adapter.class, Hello.class);
        GrizzlyServerFactory.create("http://localhost/", adapter);
    }

}

Dopo aver avviato verificatene il funzionamento seguendo http://localhost/hello.

Che bella la semplicità!

Semplificare le espressioni regolari

2010-02-04T20:47:00.003+01:00

Sono convinto che le espressioni regolari siano uno strumento potente per esprimere in modo compatto per esprimere patterns.

Sono però sono anche convinto che per molti problemi siano troppo potenti e che, proprio per il fatto che sono il loro linguaggio e molto compatto, possano essere poco leggibili.

Inoltre quando usate in un linguaggio di programmazione sono un linguaggio nel linguaggio con tutti i problemi che ne derivano. Se per esempio le state usando in Java per fare il matching delle string che iniziano con "C:\" bisogna scrivere qualcosa del tipo:

assertTrue(path.matches("C:\\\\.*"));

C'e' un modo per semplificare le cose? Io ho provato creando un piccolo DSL.

Si usa così:

String output = "Killing process 1624...done\n";

assertThat(output, looksLike("Killing process NNNN...done\n")

.where("NNNN").isA(anyNumber()));

In questo caso il matching è soddisfatto per ogni stringa dove al posto del termine "NNNN" appare un qualsiasi numero.

Questo è un'altro esempio:

String path = "C:\\Program Files";

assertThat(path, looksLike("C:\\<path>")

.where("<path>").isA(anyString()));

In questo caso mi sono inventato il termine "<path>", il bello è che non ci sono vincoli sul nome del termine.

La libreria è poco più di una proof of concept e non gestisce ancora il caso in cui il termine è ripetuto più di una volta.

Però è funzionante e testata, e presto la metterò online.

Installare Ruby on Rails su Cygwin

2010-01-21T23:03:00.001+01:00

In questi giorni sto imparando ad usare Ruby on Rails, un famoso framework per 
scrivere applicazioni web. In queste note descrivo i passi necessari 
all'installazione delle dipendenze.

Prima di tutto avete bisogno di `gem` il comando per scaricare i pacchetti ruby.
Andate sulla pagina http://rubyforge.org/frs/?group_id=126 e individuate 
l'ultima tarball.

Scaricate e installate con::

    wget http://rubyforge.org/frs/download.php/60718/rubygems-1.3.5.tgz
    tar xvfz rubygems-1.3.5.tgz
    cd rubygems-1.3.5
    ruby setup.rb install

Ora installare rails è un gioco da ragazzi, basta fare::

    gem install rails

Però non è finita, qui, perché avrete bisogno di sqlite per fare le vostre 
prove. A meno che non vogliate imbarcarvi nell'uso di mysql.

Per poter usare sqlite dovrete sia installare sqlite vero e proprio sia i 
bindings ruby. Per installare sqlite3 usate::

    apt-cyg install libsqlite3_0  libsqlite3-devel
    
se non avete apt-cyg potete installarlo con i comandi:

    wget http://apt-cyg.googlecode.com/svn/trunk/apt-cyg -O/bin/apt-cyg
    chmod u+x /bin/apt-cyg

Ora installiamo i bindings::
    
    gem install sqlite3-ruby

Ora abbiamo quasi finito e possiamo usare rails::

    rails nome-dell-applicazione

Presentazione all JUG

2009-12-10T23:27:00.002+01:00

Domani terrò una presentazione sull'uso di subversion al jug di milano. Le slide che userò sono su slideshare.

Presentazione alll'XPUG

2009-12-03T23:01:00.002+01:00

Ieri ho fatto la mia prima presentazione all'XPUG di Milano.

Ho presentato quello che ho capito del libro "Working Effectively with Legacy Code" di M. Feathers.

La cosa più bella è che la mia fidanzata è venuta a vedermi presentare ed ha avuto pure la pazienza di restare per la cena che abbiamo fatto dopo. Chissà quanto si è stufata? Continuavamo a parlare di programmazione ;)

Cos'è il codice legacy (secondo Feathers)?

2009-11-22T22:51:00.002+01:00

Come vi ho detto ho appena letto questo libro e una delle cose più interessanti che vi ho trovato è la definizione di software legacy data usata dall'autore. Infatti secondo Feathers l'aspetto caratterizzante del codice legacy è l'assenza dei test di unità automatici.

A prima vista sembra questa affermazione non abbia senso. A noi sembra che il problema dei software legacy è semplicemente che sono progettati (e scritti) male.

Come sappiamo questo potrebbe non essere un gran problema se solo potessimo migliorare il design esistente, magari riscrivendo qualche porzione. Questo tipo di modifiche ha pure un nome, si chiama Refactoring e consiste nel cambiare la struttura interna di un programma mantenendone intatto il comportamento esterno.

Il refactoring comporta la modifica del codice esistente e quindi, come tutte le modifiche, se fatta in assenza del feedback di test automatici rischia di "rompere" il comportamento esistente.

Senza test è così facile introdurre bachi durante il refactoring che presto i programmatori e managers sviluppano una grande avversione alle modifiche del codice esistente.

Le conseguenze di questa "paura del refactoring" l'instaurarsi un circolo vizioso secondo il quale il nuovo codice non può essere scritto bene perché il codice esistente è scritto male. Quindi modifica dopo modifica il codice non migliora e, spesso, peggiora.

Questi sono i ragionamenti che portano a pensare che la caratteristica principale del codice legacy sia l'assenza di test di unità automatici.

A questo punto è facile capire quale sia la soluzione per interrompere il ciclo vizioso: è necessario mettere sotto test automatici le parti di applicazione che si intende modificare. Gran parte del libro è dedicata all'aggiunta dei test automatici al software legacy per abilitarne il refactoring e renderlo sempre di più un po' meno legacy.

Cos'è il software legacy

2009-11-16T23:19:00.004+01:00

Ho recentemente finito di studiare Working Effectively with Legacy Code di Michael Feathers.

Come immaginerete il libro parla di codice legacy. Noi abbiamo tutti un'idea di cosa sia il codice legacy.
Tutti noi ne abbiamo avuto a che fare, a volte lo abbiamo creato e forse lo stiamo pure creando. Feathers nel suo libro utilizza una definizione tutta particolare ed interessante per definirlo ma in questo post vorrei invece ragionare sulla definizione di senso comune di codice legacy.

Secondo me, e penso secondo altri, il software legacy è qualcosa che possiede le seguenti caratteristiche:

è utile:

cioé serve alla azienda, crea valore.

è difficile capirne il funzionamento:

a volte ci sono delle incosistenze,
l'interfaccia d'uso non è lineare e contiene refusi ed errori storici

è fragile:

ogni modifica può comportare un malfunzionamento, per esempio ti chiedono di modificare la formattazione dell'output e poi scopri che non salva più sul database!

è difficile da modificare:

a volte una "piccola" modifica ai requisiti richiede di rivedere grandi porzioni di programma, pensarci su, discutere e alla fine si riduce al cambiare una riga di codice in un certo punto magico
a volte invece una "piccola" modifica ai requisiti richiede di fare delle modifiche in tanti diversi posti e devi ricordarti tutti i posti in cui lo devi modificare

(a volte) è stato scritto da altre persone/enti:

questo sarebbe il vero significato del termine legacy (cioè retaggio). Però nell'uso comune della parola in ambito software gli altri aspetti sono considerati più caratterizzanti. Infatti a volte si parla anche di software legacy riferendosi a software scritto da noi stessi (intesi come persona o azienda).

La caratteristica che ritengo più importante di questo tipo di software è la prima. Cioé

si tratta di un software utile e che crea utile!

Secondo me questo punto è veramente importante.

Il fatto che il programma, anche se brutto, crei valore è il motivo per cui i nostri capi ci chiedono di lavorarci.
E' il motivo per cui dobbiamo impegnarci per manutenere il programma e rendendolo migliore, o almeno ... non peggiore.

Però non è come dirlo. Non è facile. Ci vuole tecnica e impegno.

Riguardo all'impegno considero politiche del tipo "cerchiamo di toccarlo il meno possibile", "moltiplichiamo per 3.14 le stime prima di darle al management", "opponiamoci ad ogni richiesta di modifica" semplicemente non professionali.

Riguardo alla tecnica questa si è raccontata in questo libro e si acquisce studiandoloe applicandone gli insegnamenti.

Creare un menu popup

2009-10-12T21:53:00.000+02:00

Oggi ho imparato a creare popup menu...

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class PopupMenuExamle {

    public static void main(String[] args) {
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        frame.setVisible(true);
        frame.setSize(100, 100);

        final JPopupMenu popup = new JPopupMenu() {{

            add(new JMenuItem("aaa"));
            add(new JMenuItem("bbb"));
            add(new JMenuItem("ccc"));
        }};

        addPopupMenuTo(popup, frame);

    }

    private static void addPopupMenuTo(final JPopupMenu popup, Container dest) {
        dest.addMouseListener(new MouseAdapter() {

            @Override
            public void mousePressed(MouseEvent e) {
                maybeShowPopup(e);
            }

            @Override
            public void mouseReleased(MouseEvent e) {
                maybeShowPopup(e);
            }

            private void maybeShowPopup(MouseEvent e) {
                if (e.isPopupTrigger()) {
                    popup.show(e.getComponent(),
                            e.getX(), e.getY());
                }
            }
        });
    }
}

Creare una finestra trascinabile in Java

2009-10-12T21:50:00.000+02:00

Oggi ho fatto un po' di esercizio con Swing di Java. Swing è uno dei GUI toolkit di Java ed è utile conoscerlo perché è compreso nella piattaforma Java. Swing non è l'unica scelta, ne esistono altre, sul web ci sono alcune risorse che vi possono aiutare nella scelta.

Pero' io ho provato con Swing. Volevo provare una draggable window, una finestra senza bordi che si può spostare trascinandola con il mouse. Ecco il risultato:

import java.awt.Container;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JWindow;

public class DraggableBorderlessWindow {

    public static void main(String[] args) {
        final JWindow win = new JWindow();

        makeDraggable(win);

        win.setSize(100, 100);
        win.setVisible(true);
        win.setLocation(100, 100);
    }

    private static void makeDraggable(final Container window) {
        MouseAdapter dragger = new Dragger(window);
        window.addMouseMotionListener(dragger);
        window.addMouseListener(dragger);
    }

    private static class Dragger extends MouseAdapter {

        private int offsetX;
        private int offsetY;
        private final Container window;

        public Dragger(Container window) {
            this.window = window;
        }

        @Override
        public void mousePressed(MouseEvent e) {
            offsetX = window.getX() - e.getXOnScreen();
            offsetY = window.getY() - e.getYOnScreen();
        }

        @Override
        public void mouseDragged(MouseEvent e) {
            window.setLocation(e.getXOnScreen() + offsetX,
                               e.getYOnScreen() + offsetY);
        }

    }
}

Fuffa

2009-10-06T21:01:00.001+02:00

Sapreste spiegare cosa fa il vostro prodotto in modo conciso e chiaro in modo da invogliare i potenziali clienti? Oppure vi vergognate tanto di dire cosa realmente fa il vostro prodotto da
sembrarvi riduttivo dirlo e ci girate intorno?

Facciamo un esempio preso dalla pagina ufficiale di un prodotto a caso.
Il target di questo prodotto sono sviluppatori Java. Il nome del prodotto è stato nascosto sotto delle anonime XXXXX. (Non voglio problemi e quindi cancellerò qualsiasi commento che dica il nome vero del prodotto)

Ecco l'esempio:

XXXXX is an award-winning productivity tool for Java EE development. It enables your team to complete more features, fix more bugs, and release quality software on schedule and under budget by eliminating time-wasting build and redeploy phases. Your whole team can use the free 30-day evaluation.

In tutto ci sono 296 caratteri, vediamo quanti di questi sono utili.
I primi sei caratteri (contando lo spazio) sono utili, dicono il nome del prodotto.
Analizziamo il resto.

"is an award-winning productivity tool ".

Bene. Si tratta un prodotto che ha vinto premi (tipo l'oscar immagino) ed un productivity tool. Probabilmente un tool che "aumenta la produttività" ... di solito i tool si comprano pensando che la produttività aumenti. Insomma 38 caratteri di fuffa.

"for Java EE development. ".

Ahh sappiamo almeno il campo di applicazione! Caratteri utili: 25.
Totale parziale: 31 utili, 38 fuffa.

"It enables your team to complete more features, fix more bugs, and release quality software on schedule and under budget ".

Wow! Ma che cosa è una nuova metodologia di sviluppo?
E' una sfera di cristallo che legge nella mente del committente?
E' una sorta di tempo liofilizzato da usare quando si arriva la scadenza?
O sono le solite balle, un po' come quando ci ha detto che è un tool che aumenta la produttività? Insomma: 121 caratteri sprecati.
Totale parziale: 31 utili, 159 fuffa.

by eliminating time-wasting build and redeploy phases. "

Ahh, finalmente. Qualcosa si capisce. Ha a che fare con la fase di build e redeploy.
Non ho ancora capito a cosa serve ma un idea ce l'ho.
Caratteri utili: 55
Totale parziale: 86 utili, 159 fuffa.

"Your whole team can use the free 30-day evaluation. "

Questa è un informazione sul periodo di prova, è utile ma non entra nel conteggio, ne in bene ne in male.

Tirando le somme abbiamo:
Caratteri utili: 86
Caratteri fuffa: 159
Percentuale fuffa: 86/159 = 54%

Adesso miglioriamolo

Le parti utili sono:

XXXXX is a tool
for Java EE development
eliminating time-wasting build and redeploy phases.

Facciamo una prova:

XXXXX is a tool that eliminates the build and redeploy phases in Java EE development.

E' ancora oscuro ma è molto meno rumoroso. Possiamo fare di meglio. Studiamo cosa fa realmente e magari facciamoci aiutare da wikipedia.

XXXXX is a plugin for the Java Virtual Machine that enables on-the-fly reloading of changes made to Java class files.

Mettiamo tutto assieme:

XXXXX is a plugin for the Java Virtual Machine that enables on-the-fly reloading of changes made to Java class files. This is great because you can actually change source code when debugging and, more importantly, works also with Java EE applications servers.

Conteggio fuffa:

"XXXXX is a plugin for the Java Virtual Machine that enables on-the-fly reloading of changes made to Java class files. " -> 118 utili
"This is great because " -> 22 fuffa
"you can actually change source code when debugging and, " -> 56 utili
"more importantly, " -> 18 fuffa
"works also with Java EE applications servers." -gt; 45 utili

Caratteri utili: 118+56+45 = 219
Caratteri fuffa: 22+18 = 40
Percentuale fuffa: 40/219 = 18%

PS: Se pensate che ho sbagliato qualche conto probabilmente avete ragione

Utilities for managing svn:ignore properties

2009-10-04T23:47:00.000+02:00

I've just created a few commands for simplifying the usage of svn:ignore property of Subversion from command line. You can download, and see the sources on the project page.

The usage is simple, typing:

svn-ignore-add path/to/file-to-ignore

will append to the current svn:ignore property of "path/to" the string "file-to-ignore".

The project was written in Bash with TDD.
The xUnit framework used is an modified version of shunit2 that I hacked sometime ago for the trash-cli project.

My Small Software Pomodoro Timer

2009-10-03T10:08:00.001+02:00

I've just created my own home made software Pomodoro Timer.

Unlike other timers has a very simple interface.

Features/bugs:

Left time always visible.
You can drag the window where you want.
The interface is minimalist (less features, simpler interface)
The window waste less than 3k pixel of your screen.
Only three actions: start, stop, close
No Sounds
Works on Windows Only
Sources available.
Free download

Screenshots:

Start!

Running:

How Compare Word Documents in TortoiseHG using TortoiseSVN

2009-09-14T00:26:00.001+02:00

Introduction

TortoiseSVN is a mature and complete product that provides some useful features like comparison of non text based files like Word, PowerPoint, Excels and images files.

The TortoiseHg hasn't this feature so you can't, for example, visual compare Word files. Nevertheless we can configure TortoiseHg in a way that it can use the comparison features of TortoiseSVN. In this post I will choose you how to do such configuration.

Create an the invoke-tortoisesvn-diff.cmd

First of all we create a command that will invoke TortoiseSVN Diff.

Create a file named invoke-tortoisesvn-diff.cmd with the code:

SET LEFT=%1
SET RIGHT=%2
SET PROC=C:\Program Files\TortoiseSVN\bin\TortoiseProc.exe
"%PROC%" /command:diff /path:%LEFT% /path2:%RIGHT%

Place it when you want, for example in C:\Program Files\TortoiseHg.

Before continuing test the command, for example comparing two word files:

invoke-tortoisesvn-diff.cmd C:\path\to\left\document.doc C:\path\to\right\document.doc

Using absolutes path is essential.

Integrate invoke-tortoisesvn-diff in TortoiseHg

Next we tells to TortoiseHg to use this command editing the mercurial.ini.

Placed in C:\Documents and Settings\<user>\mercurial.ini.

And add the followings::

[extdiff]
cmd.tortoise_svn_diff = C:\Program Files\TortoiseHg\invoke-tortoisesvn-diff.cmd

Now we can test the integration with TortoiseHG. From a mercurial working directory do right click > TortoiseHG... > Visual Diff and the usual "Visual Diffs" window should be displayed.

From the tools dropdown list choose tortoise_svn_diff and then double click the document name and the differences should be shown in a new word document.

Duke Nukem Forever

2009-09-03T22:22:00.002+02:00

Oggi in rete ho scoperto la storia di un videogioco chiamato Duke Nukem Forever.
Si tratta di un videogioco che potrebbe essere considerato il simbolo dello sviluppo software mal gestito: lo sviluppo è iniziato 12 anni fa e non è ancora terminato!

I motivi del ritardo non li conosciamo ma si possono intuire leggendo la storia dello sviluppo su wikipedia (per esempio si legge che hanno cambiato tecnologia più di una volta, che hanno riscritto da zero alcuni componenti al posto di usare quelli già fatti, e che hanno cambiato spesso il personale).

La cosa che mi lascia sconcertato è come fa un progetto a durare così tanto senza morire? Quanti soldi avranno speso? Chi ne ha spesi così tanti e chi ha continuato a spenderli non vedendo risultati?
Incredibile.

Il protocollo di Subversion si rinnova

2009-07-21T21:54:00.001+02:00

Avete presente il protocollo HTTP di Subversion? Lo stanno migliorando e studiare come gestiscono questa miglioria mi aiuta a capire come gestire i progetti software.

Subversion supporta diversi protocolli (svn, http, e svn+ssh). Il protocollo che poggia su HTTP è forse il più comodo da usare come client perché usa solo la porta 80 (buono per i firewall e proxy trasparenti), e permette il browsing del repository con un semplice browser. Lato server il protocollo over HTTP fornisce una serie di goodies ereditate da Apache come la possibilità di usare l'autenticazione LDAP, e le stessi strumenti di logging usati per Apache. Fino ad ora questa comodità si pagava in termini di prestazioni. Come ammette lo stesso manuale di Subversion il protocollo over HTTP è più lento degli altri due.

Oltre alla velocità ci sono questioni di semplicità e di leggibilità che riguardano il protocollo. Se ho capito bene questo post che lo letto il problema sta nel fatto che il protocollo Subversion over HTTP è stato su una specifica over-ingegnerizzata: l'estensione di versioning di WebDAV.

Ora si è deciso di cambiare! La modifica è stata definita in una nuova specifica. In questo nuovo protocollo sono state rimosse tutte le complicazioni non necessarie. La parte interessante (per me) è vedere come la modifica è gestita!

Le specifiche sono scritte in un documento testo semplice messo sotto controllo di versione e automaticamente messe a disposizione su HTTP (grazie all'uso di Subversion over HTTP tra l'altro).

All'inizio c'e' una introduzione che contestualizza le modifiche e di seguito le specifiche sono dettagliate in senso top down. Lo stesso documento funge da report sullo stato del lavoro. Scendendo nel documento si trovano infatti gli elenchi di cose da implementare taggati con la scritta [DONE] o [STARTED]. Scorrendo indietro nella storia si potrebbe addirittura vedere la storia del documento e come si è evoluto il design e lo stato di implementazione.

Molto istruttivo.

--
Andrea Francia
http://andreafrancia.blogspot.com/

Confronti numerici con ndiff

2009-07-02T00:48:00.003+02:00

Ndiff permette di confrontare i file numericamente.
E' molto comodo se si vogliono confrontar gli output di programmi di calcolo numerico trascurando le differenze di formato di rappresentazione dei numeri.

 Io lo installo così:

mkdir --parent .local/{bin,src,man/man1}

cd  .local/src
wget http://ftp.math.utah.edu/pub//misc/ndiff-2.00.tar.gz
 tar xvfz ndiff-2.00.tar.gz

cd ndiff-2.00
./configure --prefix ~/.local
make install

echo 'export PATH=~/.local/bin:"$PATH"' >> ~/.bashrc
echo 'export MANPATH=~/.local/man:"$MANPATH"' >> ~/.bashrc

Mission Impossible

2009-06-24T00:14:00.001+02:00

Oggi dovevo recarmi a Roma per lavoro. Alla fine ce l'ho fatta ma è stata un'impresa!

Sono partito da casa alle 7.40, ho preso il Freccia Rossa di trenitalia.
Prima di salire alla stazione avevo letto sul tabellone: "possibili ritardi di 20 minuti dei treni da e verso Roma".

A Bologna mi hanno soppresso il treno. Nessun avviso prima di Bologna. E' venuto il capotreno in carrozza a gridare: "questo treno è sopresso! andate a prendere quello al binario 10".
Il nuovo treno conteneva la gente di tre treni diversi. I posti non bastavano. Ho gentilmente offerto il mio ad una suora.

il treno è arrivato a Roma con un ritardo mostruoso. Circa 160 minuti.

Arrivato a Termini mi dirigo verso la metro. Lì scopro che la linea B di Roma è inutilizzabile: Guasto elettrico!
Prendo due autobus strapieni e arrivo al lavoro.

Arrivo sul posto di lavoro con circa 3 ore di ritardo e non sono ancora passato dall'albergo a lasciare la valigia.
Lavoro per il poco tempo che rimane alla chiusura dell'azienda e mi dirigo verso il BnB.

Il BnB sembra non esistere e sembra un tentativo di truffa o qualcosa di simile.

Chiedo alla fidanzata di trovarmi il numero di un hotel che ho già usato in passato.
Chiamo questo hotel e la receptionist mi propone un prezzo che è il 30% più alto di quello scritto su Internet.

Contratto il prezzo è ottengo che sia solo 2 euro più alto di quello rilevato dalla mia fidanzata su Internet.

Che giornata!

Mio papà è un grande

2009-06-17T23:34:00.001+02:00

Ieri dopo il lavoro mi sono diretto verso la Città per incontrare alcuni amici.

Ho preso l'autostrada e dopo qualche kilometro la macchina ha cominciato a perdere potenza!!!! Panico!
Ma che gli è successo! Chiamo mio padre al cellulare: "Papà! La macchina è strana ha perso potenza! ... non va oltre i 2000 giri ... pero' va' ... sto andando avanti con le quattro frecce ... se riesco esco al prossimo casello altrimenti mi tocca fare venire il carroattrezzi e pagare un sacco per la chiamata".

Andando a 40 km/h arrivo fino al casello più vicino esco dall'autostrada e aspetto mio padre.

Lui arriva, sente il rumore del motore e capisce qualcosa, poi mi chiede "accellera un po'" sente il rumore e capisce qualcosa...
Guarda il motore e capisce qualcosa e dice: "Mmmh ... forse la cinghia ... mi ci vorrebbe una chiave del 13 ... "

Poi mi dice: "Vai pure alla Città a trovare i tuoi amici con la mia macchina, io torno a casa con la tua e cerco di capire cos'ha".

"Grazie!" è la mia risposta.

Riprendo il viaggio e dopo 10 minuti il cellulare squilla ... è mio padre! cavolo! si sarà fermata la macchina? Rispondo.
Mio padre: "Andrea! Ho incontrato un signore che mi ha gentilmente una chiave del 13. Adesso la macchina va che è una meraviglia! Comunque adesso la porto a casa e la stringo bene"

Certo che è bravo!

Chiedere dei (pseudo) rimborsi a Trenitalia

2009-06-03T22:48:00.004+02:00

Per gli utenti dei treni a lunga percorrenza come me ecco il mio consiglio. Non so se lo sapete ma se il treno arriva in ritardo potete chiedere un bonus (non è un vero rimborso, è un bonus) con il quale vi sconteranno il prossimo biglietto. Dato che ogni mese faccio circa un 2Mm (due megametri = 2000km :) in treno mi porto sempre dietro una copia del modulo di rimborso e lo compilo appena il treno arriva. Il modulo lo trovate nelle stazioni. Quando riesco lo lascio direttamente in stazione al mio arrivo così non devo neanche spedirlo per posta. Questo post spiega i dettagli ma le informazioni ufficiali le trovate sul sito di trenitalia.

Milano XPUG 13/5/09: Deep Dynamics and Lean Startups

2009-05-14T12:00:00.001+02:00

Ieri sono andato ad meeting su XP.

Come vedere i film sul Nintendo DS

2009-03-09T21:23:00.002+01:00

==================================
Come vedere i film sul Nintendo DS
==================================

Lo sapevate che si possono vedere intermi film sul Nintendo DS? Sapevatelo.

I filmati si possono vedere usando MoonShell, un media player per Nintendo DS.

Date le limitazione hardware del dispositivo non è possibile visualizzare i 
video nel formato originale, essi vanno ridotti a livelli di bitrate che il 
Nintendo DS sia in grado si sopportare. Il formato di questi video a bitrate 
ridotto si chiama DPG.

Questo post spiega come convertire un video in formato .AVI in formato .DPG in 
modo che possano essere visti sul Nintendo DS. 
La guida è basata su Ubuntu 8.10 ma probabilmente sono sufficienti piccole 
modifiche per applicarla ad altri sistemi GNU/Linux.

Installazione
=============
Il software si chiama `dpgconv` ed è uno script python che richiede altri 
due software:

 - mplayer (e mencoder)
 - mpeg_stat
 
Installazione di mplayer e mencoder
-----------------------------------
Questi due software si installano semplicemente con::

  sudo apt-get install mplayer mencoder

Installazione di mpeg_stat
--------------------------
Il software `mpeg_stat` sembra che non abbia più una sua homepage, per 
scaricarlo dovete cercare e trovare qualche mirror che ne abbia ancora una 
copia. Io l'ho trovato qui: 
ftp://ftp.riken.go.jp/pub/FreeBSD/distfiles/mpeg_stat-2.2b-src.tar.gz e l'ho 
installato con i seguenti comandi::

  cd ~/.local/src
  wget ftp://ftp.riken.go.jp/pub/FreeBSD/distfiles/mpeg_stat-2.2b-src.tar.gz
  mkdir mpeg_stat-2.2b
  cd mpeg_stat-2.2b
  tar xvfz ../mpeg_stat-2.2b-src.tar.gz
  cd mpeg_stat
  make
  cd ~/.local/bin
  ln -s ../src/mpeg_stat-2.2b/mpeg_stat

Installazione di dpgconv
------------------------
Dato che si tratta di un semplice script la procedura di installazione 
consiste solo nello scaricare questo script e renderlo eseguibile.

Io ho fatto così::

  wget http://theli.ho.com.ua/dpgconv/dpgconv-8.py
  chmod u+x dpgconv-8.py

Una volta installato verifichiamo che dpkgconv rilevi tutti i programmi che 
servono digitando::

  ./dpgconv-8.py

Dovrebbe dire qualcosa di simile a::

   mpeg_stat -- MPEG Analyzer for MPEG I video streams (version 2.2b)
   MPlayer 1.0rc2-4.3.2 (C) 2000-2007 MPlayer Team
   MEncoder 2:1.0~rc2-0ubuntu17 (C) 2000-2007 MPlayer Team
   It seems we found all programs :)...continuing
   ______________________________________________

Conversione dei filmati
=======================
La conversione è semplicissima, per convertire il video `esempio.avi` si usa
il comando::

  ./dpgconv-8.py esempio.avi

La conversione potrebbe durare un po', specialmente su macchine lente. Il 
risultato della conversione è un file con lo stesso basename ma con estensione 
.dpg (nel nostro caso `esempio.dpg`), naturalmente questo file è quello che 
deve essere copiato sulla vostra flash card e visualizzato sul Nintendo DS.

Qualità video/audio
===================
Non aspettatevi un'alta qualità video, il Nintendo DS non è stato progettato è 
limitato e non è stato progettato per questo. Se avete bisogno di una 
qualità alta forse avete bisogno di qualcos'altro, come la PSP. 

References
==========
 - Home page di dpgconv: http://theli.is-a-geek.org/blog/static/dpgconv
 - MoonShell on Wikipedia: http://en.wikipedia.org/wiki/MoonShell
 - DPG on Wikipedia: http://en.wikipedia.org/wiki/NDs-mPeG

Building Chandler on an am64 Ubuntu

2009-02-04T20:20:00.003+01:00

After many days of tries finally I managed to run Chandler Desktop on my Ubuntu. I had tried the binary installation but it didn't work, running chandler the following problem is reported:

$ chandler
...
ImportError: /home/andrea/.python-eggs/PyICU-0.8-py2.5-linux-i686.egg-tmp/_PyICU.so: wrong ELF class: ELFCLASS32

Fortunately you can always build it from sources. Unfortunately downloading the sources and compiling take much time and is not so easy know which packages you need to build it. To install all(? surely I missed someone) the needed packages do:

sudo apt-get install libicu-dev
sudo apt-get install libssl-dev
sudo apt-get install python-gdata
sudo apt-get install ant
sudo apt-get install default-jdk
sudo apt-get install lib32icu38
sudo apt-get install curl

To get the sources and build them:

svn checkout http://svn.osafoundation.org/chandler/trunk chandler
cd chandler
cd external
export BUILD_ROOT=$(pwd)
make world # wait ... wait ... wait

Now, if the build succeed you can run chandler with:

cd ../chandler
./chandler

If the build fails you, probably, need to install some package that I missed. To discover which package you can use google. For example if you got this error:

SWIG/_m2crypto.i:23: Error: Unable to find 'openssl/opensslv.h'

You should search on google these words "openssl/opensslv.h Ubuntu filelist", the first results should be the page of missing package, in this case is http://packages.ubuntu.com/feisty/amd64/libssl-dev/filelist So it's simple add the needed package:

apt-get install libssl-dev

Utility screen

2009-01-19T20:58:00.002+01:00

Come usare screen
=================
Questo articolo introduce l'utilizzo dell'utility screen. L'articolo è scritto
per la mia fidanzata, ciò nonostante, l'articolo potrebbe risultare utile 
anche ad altre persone.

La mia fidanzata deve utilizzare PuTTY per collegarsi ai computer del lavoro 
sui quali avvia programmi di calcolo scientifico. L'esecuzione di questi 
programmi dura spesso parecchie ore. Il problema è che, durante l'esecuzione di 
questi programmi, la connessione potrebbe cadere con il risultato di terminare 
prematuramente l'esecuzione del programma. 

Dato che questa scocciatura capita spesso alla mia fidanzata e dato che le 
voglio bene le spiegherò come evitare questo problema.

Nel mondo unix e linux esistono due soluzioni a questo problema e si tratta 
delle utility `nohup` e `screen`. In questo articolo spiegherò come usare 
`screen`. 

Cos'è screen
------------
`screen` è un utility che permette di creare terminali virtuali che rimangono
attivi anche dopo aver fatto il log out dal sistema o dopo che la connessione è
interrotta.

Esempio di utilizzo
-------------------
Dopo esserci collegati al server con PuTTY avviamo `screen`:

 $ screen

Apparirà una schermata che riporta qualche informazioni riguardanti il copyright
e la licenza di utilizzo. Usiamo RETURN per chiudere questa schermata.
 
A questo punto saremo entrati nel terminale virtuale di screen.
Adesso possiamo avviare il programma di calcolo la cui durata è molto lunga. 
Dato che io non ho tale programma ne simulerò l'esecuzione usando il comando

 $ yes > /dev/null

che ha durata indefinita.

Ora simuliamo l'interruzione del collegamento chiudendo la finestra di PuTTY.
Ricolleghiamoci al server (sempre con PuTTY) e scriviamo:

 $ screen -r 

e magicamente recuperiamo la sessione precedente dove il comando `yes` (o il 
programma di calcolo) sta ancora girando.

Adesso supponiamo che il comando non abbia ancora terminato ma vogliamo comunque
tornare in possesso della shell. Per uscire da screen usiamo
la combinazione di tasti "CTRL+A, D". Questo dovrebbe farci ritornare alla shell
iniziale.

    $ screen -r
    [detached]
    $

Lo screen è passato allo stato "Detached", cioé è ancora attivo ma non è più 
associato a nessun terminale.

Per recuperare questo screen è sufficente scrivere:

 $ screen -r

Infine, per terminare uno screen è sufficiente terminare la shell caricata da 
esso, quindi (quasi per tutte le shell) si tratta di usare il comando exit.

 $ exit

Avviare molti screen
--------------------
E' possibile tenere in esecuzione più di uno screen alla volta. Per avviare un 
secondo screen è sufficiente scrivere il comando screen, anche da un terminale 
screen.
Con il comando "screen -ls" invece è possibile elencare gli screen attualmente 
in esecuzione, ad esempio 

 $ screen -ls
 There are screens on:
        2893.pts-0.ubuntu       (01/18/2009 07:40:56 PM)        (Attached)
        2854.pts-3.ubuntu       (01/18/2009 07:37:57 PM)        (Attached)
        2727.pts-0.ubuntu       (01/18/2009 07:35:23 PM)        (Detached)
 3 Sockets in /var/run/screen/S-andrea.

L'output nell'esempio mostra che ci tre "screen" attivi. Due screen sono nello 
stato "Attached" (cioè attualmente visualizzato su un terminale), mentre un 
terzo si trova nello stato "Detached" (cioé in esecuzione in background, quindi
non visibile su nessun terminale).

Per ogni "screen" è inoltre indicato un numero identificativo. Il numero 
identificativo è utile per specificare su quale istanza si vuole eseguire un 
comando, per esempio è possibile scrivere:

 $ screen -r 2727

Scrivania

2009-01-07T19:50:00.002+01:00

Avete presente la Scrivania del computer? Come no, mah sì quella cosa che c'e' dietro tutte le finestre, quella dove ci puoi mettere lo sfondo... come? Voi la chiamate "Desktop"? ... Sì in effetti anch'io ho sempre fatto così, ... chissà poi che cosa si sono fumati i traduttori della versione italiana di Gnome? Avete un installazione di GNU/Linux con Gnome con lingua di sistema italiana? Provate un po' a vedere in che modo improponibile hanno chiamato la cartella che dovrebbe essere "/home/andrea/Desktop" ... l'hanno chiamata "/home/andrea/Scrivania" !

Creare un repository personale svn+ssh://

2008-12-30T21:20:00.004+01:00

Ingredienti (requisiti):

Un server unix (o unix-like) accessibile da internet
Subversion installato sul server unix
Una macchina Windows che fa da client
TortoiseSVN e PuTTY installati sulla macchina Windows
Una file .ppk con la propria chiave SSH

Procedimento: Accedere al server unix e creare il repository, con i comandi:


mkdir ~/svn-repo
svnadmin create  ~/svn-repo

Installare la propria chiave pubblica sul server unix:

mkdir ~/.ssh
chmod 700 ~/.ssh
echo "echo <my-rsa-key>

>> .ssh/authorized_keys" Per conoscere la propria chiave pubblica aprite il vostro file .ppk con PuTTYgen. Se non avete un file .ppk createlo (sempre con PuTTYgen). Usate Pageant per caricare la chiave .ppk. Verificate che quando vi collegate con PuTTY che l'autenticazione avvenga senza dover immettere la password. A questo punto provate a collegarvi al server con TortoiseSVN usando il seguente url of repository:


svn+ssh://username@server-unix.com/home/username/svn-repo/

E' importante che l'url contenga anche la specifica dello username (la parte "serenity@") altrimenti TortoiseSVN te lo chiederebbe e ciò sarebbe noioso. Se non conoscete il path assoluto usate il comando "pwd" dalla shell del server unix. Commenti:

L'utilizzo di Pageant e dell'autenticazione basata su chiave pubblica è consigliato perché altrimenti altrimenti dovresti riscrivere più e più volte la password durante anche una singola operazione.
Il server svn+ssh:// è comodo perché è più facile da installare che il corrispondente servizio http:// ma ha una serie di svantaggi, questi sono descritti nel libro svnbook.

Pixel nostalgia

2008-12-26T21:08:00.003+01:00

Per i nostalgici, per quelli che dicono "non fanno più i giochi di una volta", per quelli che si ricordano quando si riusciva a contare i pixel degli sprites e che magari hanno provato pure a riprodurre i personaggi su carta millimetrata ... per tutti voi questo sito fa per voi.

Se volete farmi un regalo, avete tempo e sapete ricamare prendete pure spunto dal sito in questione. Anche le torte fatte a quadratini vanno bene.

Installare setuptools per python 2.6

2008-12-11T21:50:00.002+01:00

Lo sapete che Python è produttivo, vero? E' così produttivo che c'e' una libreria per fare gli enum. Già inclusa nell'installazione ? No, te la devi scaricare ... Come? Semplice! Python è produttivo, basta usare il comando easy_install! Basta fare

    easy_install enum

Ok! Bello! Ma non va. Come mai? Perché prima ti devi installare easy_install! Basta andare sulla pagina ufficiale di setuptools per farlo. Pero' ...

io ho Windows
io l'ultima versione (stabile) di Python la 2.6.1
sulla pagina di Download di setuptools non c'e' l'installer per la 2.6.1!

Va bene allora cosa posso fare? Ci sono tante possibilità (certo python è produttivo), tutte elencate nella pagina , eccole:

Posso sempre installarlo con easy_install ... -_- ... certo posso installare il programma che non ho con il programma che non ho!
Posso installarlo usando il mio comando sh, con
```
sh setuptools-0.6c9-py2.6.egg
```

peccato che funziona con tutto (cygwin, linux, unix, ...) ma non con Windows ... per forza non c'e' la bash in Windows (o per lo meno non ce ne sono molte).

La soluzione comunque c'e', ma non si trova sulla graziosa pagina di setuptools, ma si trova con google ed è questa.

Ti scarichi il file setuptools-0.6c9.tar.gz dalla pagina di setuptools
Lo decomprimi (con 7-Zip per esempio)
E crei da solo la distribuzione per Windows

cd setuptools-0.6c9

python setup.py bdist_exe

Si dovresti ottenere un file setuptools-0.6c9.win32.zip, che contiene le cartelle

Python26

Libs
Scripts

Le cartelle Libs e Script vanno messe sotto C:\Python26
La cartella C:\Python26\Scripts va aggiunta al PATH.

A questo punto dovreste essere in grado di usare easy_install...

C:\Documents and Settings\Andrea>easy_install enum Searching for enum Reading http://pypi.python.org/simple/enum/ Best match: enum 0.4.3 ...

Finalmente posso usare gli enum ... in Java erano già dentro il linguaggio ... alla faccia della produttività.

Python è produttivo?

2008-11-16T18:56:00.005+01:00

Introduzione In giro per la rete si dice che "Python è più produttivo di Java". Uno degli articoli che ne parla è http://www.ferg.org/projects/python_java_side-by-side.html. La tesi di base dell'articolo può essere riassunta con la seguente frase: "Dato che i programmi in Python sono più corti dei programmi in Java allora si fa prima a scrivere un programma in Python".
Questa affermazione non mi ha mai convinto più di tanto ma sembra che sia entrata nella cultura popolare dei programmatori, almeno della parte che usa Python.
Io mi sto trovando male con Python, e non mi sento più produttivo, di seguito vi racconto una delle mie ultime esperienze con Python e che dovrebbe farvi capire quali sono le mie perplessità riguardo a questa teoria della maggiore produttività.
Sono conscio del fatto che potrei non essere produttivo perché non lo conosco abbastanza bene, oppure perché conosco troppo bene il Java. Il problema è: quanto studio prima di diventare "produttivi" in Python?
Personalizzare la classe OptionParser. La classe optparse.OptionParser della libreria standard di python aiuta ad implementare in maniera semplice un'interfaccia a linea di comando.
La documentazione su http://www.python.org/doc/2.5.2/lib/module-optparse.html spiega come utilizzare la classe nel caso più semplice.

from optparse import OptionParser

parser = OptionParser()
parser.add_option("-f", "--file", dest="filename",
                  help="write report to FILE", metavar="FILE")
parser.add_option("-q", "--quiet",
                  action="store_false", dest="verbose", default=True,
                  help="don't print status messages to stdout")

(options, args) = parser.parse_args()

OptionParser è configurabile. Per esempio è possibile specificare un oggetto formatter diverso da quello di default per avere maggiore controllo sul formato del messaggio di help.
La signature del costruttore di OptionFormatter è la seguente:

class OptionParser (OptionContainer):
    def __init__(self,
                 usage=None,
                 option_list=None,
                 option_class=Option,
                 version=None,
                 conflict_handler="error",
                 description=None,
                 formatter=None,
                 add_help_option=True,
                 prog=None,
                 epilog=None):

Per cui per utilizzare un oggetto formatter diverso da quello predefinito basterebbe fare:

from optparse import OptionParser

parser = OptionParser(formatter=MyFormatter())
parser.add_option("-f", "--file", dest="filename",
                  help="write report to FILE", metavar="FILE")
parser.add_option("-q", "--quiet",
                  action="store_false", dest="verbose", default=True,
                  help="don't print status messages to stdout")

(options, args) = parser.parse_args()

Ma rimane il problema: come costruisco la classe MyFormatter? Quali metodi deve implementare? La documentazione del costruttore di OptionParser non ci aiuta: non c'è! La signature del metodo non ci aiuta: in Python non è richiesto e non si usa specificare l'interfaccia che un oggetto in input deve implementare. Come faccio a disegnare la mia implementazione di Formatter se non esiste una specifica dell'interfaccia?
Perché dicono che il python è più produttivo? Dicono che Python è più produttivo "perché scrivi meno codice". E' questo il codice che si risparmia di scrivere? Lo scrittore di OptionParser ha risparmiato due secondi ha scrivere il nome dell'interfaccia nella signature del metodo, bene. Io quanto tempo devo perdere per capire quali sono i metodi che devo implementare per scrivere un Formatter? Per andarmi a rivedere il codice sorgente della classe OptionParser e le altre classi del modulo optparse?

Pronti ad iscrivervi al Registro degli Operatori di Comunicazione?

2008-11-11T00:18:00.001+01:00

Ecco la notizia: http://punto-informatico.it/2468674/PI/News/camera-manda-avanti-ddl-anti-blog.aspx Vado a letto, la commenterò un'altra volta.

Gita Grazzano Visconti

2008-10-20T23:04:00.008+02:00

Sabato scorso io e la mia fidanzata (che amo tantissimo) siamo andati a visitare Grazzano Visconti. L'idea è stata di Elisa, io guardavo con sospetto l'idea di visitare un paese medievale ricostruito. Nonostante questo ho scoperto che un certo fascino nostalgico questo posto ce l'ha soprattutto per la sua storia. Ma cominciamo dall'inizio... Cos'è Grazzano Visconti? E' un paese dall'aspetto e storia particolare. Lo chiamano Villaggio Medievale, in realtà si tratta di una ricostruzione neo-mediovale che hai giorni nostri assomiglia più che altro ad un parco a tema. Sebbene sia facile obiettare che non si tratta affatto del tipico villaggio medievale (a quei tempi le case erano piu' che altro di legno non di muratura) dopo uno sguardo più attento ci si accorge del suo vera essenza: il tentativo di preservare una serie di stili e costumi che all'inizio del secolo stavano per andare perduti. Le case del borgo sono state costruite riprendendo gli stili e in certi casi copiando edifici storici destinati alla distruzione per fare posto a edifici più moderni. L'artefice di tutto questo era il facoltoso Giuseppe Visconti che in pieno spirito romantico voleva preservare il piu' possibile il mondo che stava scomparendo sotto i suoi occhi. Il borgo fu anche sede di un esperimento di socialismo utopico da parte dello stesso Visconti. L'idea era quella di costruire una società ideale che si auto-preservasse nel tempo. L'economia del borgo si sarebbe basata sulle botteghe d'arte gestite dai suoi abitanti. Per avviare quest'idea Giuseppe istituì una scuola d'arte presso il paese e predispose che le case fossero costruite per ospitare le botteghe. Ogni casa era a due piani. Al primo piano vi sarebbe dovuta essere la bottega al secondo l'abitazione. In questo modo la città sarebbe rimasta sempre attiva perché la gente avrebbe abitato e lavorato nello stesso luogo e il paese non sarebbe diventato deserto di sera. Secondo la visione socialista di Giusppe tutti dovevano perlomeno apparire uguali nonostante le differenze di status sociale. Fu istituito il costume ufficiale del paese (in stile medievale) che tutti (dal più povero al più ricco) usavano. Adesso l'esperimento non so dire se l'esperimento abbia funzionato o meno. Magari ha funzionato in parte. Credo che oggi l'economia del borgo si basi essenzialmente sul turismo e oggi non si usano più gli abiti ufficiali. Il paese pero' è rimasto e le case che implementano gli stili che Giuseppe voleva preservare ci sono ancora e probabilmente il turismo aiuterà a preservarle. Update 2008-10-22 Ecco le foto:

To change this template, choose Tools | Templates

2008-10-16T23:06:00.005+02:00

Every time I create a new class in Netbeans it creates a file with this text an the top of the .java file:

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

What is this? I dont want it? How to remove it? I try to follow the instructions. I select from the menu Tools > Template and the Template Manager appears. Now. Where I should go? I asked this to myself for a lot of time... Now I discovered the solution, I should choose License > Default Licenses then click Open in Editor. This will open the Default License file that you can easily customize:

<#if licenseFirst??>
${licenseFirst}

${licensePrefix}To change this template, choose Tools | Templates
${licensePrefix}and open the template in the editor.
<#if licenseLast??>
${licenseLast}

Cosa succede l'8 Agosto?

2008-08-05T22:45:00.003+02:00

Alle ore 8.08PM (ora di Pechino) del 8 agosto 2008 inizieranno le Olimpiadi di Pechino. Da noi dovrebbero essere le 12:08 AM, almeno così dicono. Invece alle 02:45 AM saranno 31 anni da quando sono nato. Alle 02:45 del 8 agosto 1977 emettevo il mio primo vagito. Era il mio primo tentativo di comunicare, per far sapere che c'ero e che mi sarebbe dispiaciuto essere coccolato un po'. Il post di oggi non è tanto diverso da quel mio primo messaggio, solo un po' piu' sofisticato nella forma e nel mezzo. Quindi se mentre guardate la televisione, o ascoltate la radio, sentite che stanno iniziando le olimpiadi, se vi ricordate di questo post, e se vi va mandatemi gli auguri che mi faranno piacere. Update 2008-08-06: ho modificato il post per renderlo meno patetico.

Mediaset ha detto "Basta!"

2008-08-04T23:08:00.005+02:00

Come sapete Mediaset ha depositato un atto di citazione contro YouTube e Google per illecita diffusione e sfruttamento commerciale di file audio-video di proprietà delle società del Gruppo. Hanno chiesto 500 fantamilioni di dobloni spaziali come risarcimento. Sulla blogosfera un sacco di gente si schiera dalla parte di YouTube. Io mi chiedo: Perchè? Io non so se YouTube deve dare tutti questi spaziodollari a Mediaset, ma mi chiedo: "Perché no?". Io sono sicuro che YouTube guadagna molti soldi grazie ai video di cui non si pone neanche il problema di avere il diritto di ridistribuire. Altrimenti la Google non l'avrebbe comprata. Quello che mi fa ridere e pensare che YouTube potrebbe semplicemente difenderci dicendo: "Ma non li ho messi io! Li hanno messi gli utenti ... vai a chiedere i soldi a loro..." Mi fa ridere pensare che questi utenti siano le stesse persone che difenderebbero YouTube. Cari utenti YouTube avete toppato.

Print the stack trace in bash

2008-07-30T10:57:00.004+02:00

Ieri ho partorito una semplice funzione che trovo molto comoda per debuggare gli scritp shell, si chiama print_stack_trace. print_stack_trace andrebbe invocata quando si incontra una condizione di errore e si vuole risalire a qual'e' stato il flusso delle chiamate che l'ha provocata. Un esempio di utilizzo è il seguente:

save_to_file() {
    local filename="$1"
    if [[ -e $filename ]]; then
        echo "File already exists: $filename" >2
        print_stack_trace
    exit 1
    fi

... # scrittura su file
}

Quando per qualsiasi motivo la funzione save_to_file() è invocata con un argomento non valido stampa un messaggio di errore seguito dall'elenco delle chiamate a funzione che hanno portato all'errore. Per esempio:

File already exists: test-file
Stack trace:
save_to_file(./print-stack-trace.bash:13)
function_three(./print-stack-trace.bash:22)
function_two(./print-stack-trace.bash:26)
function_one(./print-stack-trace.bash:30)
main(./print-stack-trace.bash:33)

La funzione print_stack_trace è la seguente:

# print_stack_trace: print the stack trace in bash
#
# Copyright (C) 2008 Andrea Francia Trivolzio(PV) Italy
# See also: http://andreafrancia.it/
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 3 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .
#
print_stack_trace() {
echo "Stack trace:"
for (( i=1; i<${#FUNCNAME[@]}; i++)); do      echo " ${FUNCNAME[$i]}(${BASH_SOURCE[$i]}:${BASH_LINENO[$i-1]})"   done }

coLinux - Linux dentro Windows

2008-07-24T21:27:00.005+02:00

In questi giorni ho reinstallato coLinux. Sapete cos'è? E la manna dal cielo per quelli che come me hanno deciso di tenere tutto su Windows ma hanno ancora bisogno di usare Linux. E' un software che consente di avviare il kernel di Linux all'interno di Windows. Una volta avviato coLinux è possibile accedervi sia attraverso la console (virtuale) oppure via rete (attraverso una scheda di rete virtuale). Io lo uso per continuare a sviluppare il mio programma per linux senza dover riavviare il computer. Quando ne ho bisogno mi ci collego in ssh attraverso putty e faccio quello che devo fare. Sul mio sito su google sites ho creato una pagina che riporta un po' di appunti riguardo coLinux.

Un nuovo dottore

2008-07-17T20:30:00.003+02:00

Da oggi abbiamo un nuovo ingegnereedilebarraArchitetto. Complimenti Ingegnere!

trash-cli incluso in Ubuntu e in Debian

2008-07-17T01:05:00.002+02:00

Cercando su internet ho scoperto con mia grande sorpresa che il mio software è stato aggiunto sia a Ubuntu che a Debian:

Credo che per installarlo basti fare: apt-get install trash-cli Però dovrebbe funzionare solo sulle versioni intrepid di Ubuntu e unstable di Debian. Provate e fatemi sapere.

Differenze tra AWT, Swing e SWT

2008-07-11T13:21:00.003+02:00

Per Java sono disponibili tre diversi gui toolkit: awt, Swing,swt. Perché esistono tre diverse soluzioni per lo stesso problema? Perché non esiste (ancora) una soluzione che va bene in tutti casi. Quest'articolo che è stato recentemente segnalato su it.comp.java spiega i pregi, i difetti, e le particolarità di ognuna di queste tecnologie.

L'ideona del loggingDecorator

2008-07-01T00:03:00.006+02:00

Oggi ho partorito l'ideona del loggingDecorator. Anche se sono sicuro che è già venuta a mille altre persone ve la dico lo stesso. Fate finta che vi serve aggiungere ad ogni metodo dei messaggi di debug del tipo "sono entrato nel metodo", "sto uscendo dal metodo" o simili. Uno con poca fantasia farebbe così:

public void someMethod() {
  logger.debug("Begin of someMethod()");

  ... // corpo del metodo

  logger.debug("End of someMethod()");
}

Io pero' dovevo debbuggare le chiamate a una classe che aveva molti metodi e non volevo usare il copia incolla. Ho preferito scomodare il design pattern decorator e la Java Reflection. Ho usato:

    EntityManager em = ...
  em  = LoggingDecorators.loggingDecorator(em, EntityManager.class)

Avendo definito

public class LoggingDecorators {
  private static final Logger logger =
          Logger.getLogger(LoggingDecorators.class.getName());

  public static <T> T loggingDecorator(
              final T target,
              final Class<T> targetClass) {
      return (T) Proxy.newProxyInstance(targetClass.getClassLoader(),
              new Class[] { targetClass}, new InvocationHandler() {

          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
              logger.info("Begin of " + method);
              try {
                  return method.invoke(target, args);
              } catch(InvocationTargetException ex) {
                  throw ex.getCause();
              } finally {
                  logger.info("End of " + method);
              }
          }
      });
  }
}

Foto del viaggio a Londra

2008-06-23T22:04:00.003+02:00

La mia dolce metà (Elisa) ha messo su picasa le foto che abbiamo fatto a Londra durante il nostro ultimo viaggio. Guardatele se vi va.

Su Linux.com esce un articolo riguardo a trash-cli

2008-06-21T16:26:00.002+02:00

Ho scoperto che su linux.com è uscito un articolo che parla del mio progetto opensource. Non vi dico quanto mi faccia piacere questa cosa. Adesso ho capito perché il 17 giugno 2008 il mio sito ha ricevuto così tante visite.

Relazioni molti a molti con JPA

2008-06-20T21:35:00.007+02:00

Oggi ho imparato a fare le relazioni molti a molti con JPA. E' abbastanza semplice. Ve lo spiego con un esempio. Abbiamo due entità

Book
Author

Un libro puo' essere stato scritto da uno o piu' autori. Un autore può aver scritto uno o piu' libri. Per rendere la relazione basta usare @ManyToMany, nel nostro caso: Book.java:

public class Book implements Serializable {
private Long id;
private List<Author> authors = new ArrayList<Author>();
protected String title;

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="id")
public Long getId() {
    return id;
}

@ManyToMany(cascade=CascadeType.PERSIST)
public List<Author> getAuthors() {
    return authors;
}

public String getTitle() {
    return title;
}

public void setTitle(String title) {
    this.title = title;
}

public void setId(Long id) {
    this.id = id;
}

public void setAuthors(List<Author> authors) {
    this.authors = authors;
}

}

Author.java

@Entity
@Table(name="Autores")
public class Author implements Serializable {
private Long id;
protected String name;
private List<Book> books;

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="id")
public Long getId() {
    return id;
}

@ManyToMany(mappedBy = "authors")
public List<Book> getBooks() {
    return books;
}

public String getName() {
    return name;
}

public void setId(Long id) {
    this.id = id;
}

public void setName(String name) {
    this.name = name;
}

public void setBooks(List<Book> books) {
    this.books = books;
}

}

Esempio di utilizzo:

EntityManager em = ...

Author author1 = new Author();
Author author2 = new Author();
Author author3 = new Author();

author1.setName("Pippo");
author1.setName("Pluto");
author1.setName("Paperino");

Book book1 = new Book();
book1.setTitle("Vivere a topolinia");
book1.getAuthors().add(author1);
book1.getAuthors().add(author2);
book1.getAuthors().add(author3);

Book book2 = new Book();
book2.setTitle("Vivere a Paperopoli");
book2.getAuthors().add(author3);

em.persist(book1);
em.persist(book2);

Nota sul mapping Le relazioni molti a molti non possono essere espresse direttamente sui database relazionali, è infatti necessario introdurre una tabella che faccia da ponte. Nei casi semplici è possibile ignorare questi dettagli perché sono gestiti dal provider JPA. Però nel caso la struttura del database sia già definita e necessario istruire JPA in modo che utilizzi la tabella ponte giusta. Questo si fa usando l'annotazione @JoinTable. Per esempio nel caso la tabella ponte sia definita come:

CREATE TABLE "LIBROS_AUTORES" (
  "libros_id" BIGINT NOT NULL,
  "autores_id" BIGINT NOT NULL);

Useremo annoteremo getAuthors nel seguente modo:

 @JoinTable(
    name="LIBROS_AUTORES",
    joinColumns=@JoinColumn(name="libros_id", referencedColumnName="id"),
    inverseJoinColumns=@JoinColumn(name="autores_id",referencedColumnName="id")
)
public List<Author> getAuthors() {
    return authors;
}

Dov'è il preprocessore di Java?

2008-06-11T23:21:00.008+02:00

In C e C++ c'e' il preprocessore, e in Java? In Java non c'è. Solitamente il preprocessore in C o C++ si usa per fare una delle seguenti cose:

definire costanti (vedi nota sotto)
mettere funzioni inline (vedi nota sotto)
gestire l'inclusione multipla degli header
includere selettivamente una parte machine dependent
attivare o disattivare il debug

In Java queste necessità sono generalmente risolte in maniera diversa oppure non sono risolte perché non sono così sentite.

Vediamole una per una.

1) Definire costanti

Le costanti si definiscono con la parola chiave final, esempio:

public static final double PI = 3,14;

2) Mettere funzioni inline Le funzioni inline non si possono mettere in Java. In Java di solito queste ottimizzazioni di basso livello sono lasciate al compilatore e al compilatore JIT. L'unica cosa che si può fare è dichiarare una funzione final.

public static final int sum(int a, int b) {
return a+b;
}

Se il compilatore vuole potrebbe decidere di mettere questa funzione inline, ma non è garantito.
3) Gestire l'inclusione multipla degli header Questo problema in Java non esiste in quanto non ci sono header files.
4) Includere selettivamente una parte machine dependent Il codice machine dependent in Java solitamente viene affrontato nel seguente modo. Si crea una classe astratta neutrale che va bene per tutti i sistemi operativi ma che di fatto evita di implementare i metodi specifici dalla piattoforma. In seguito si crea per ogni piattaforma supportata una classe concreta che estende la classe astratta.
A volte al posto di usare una classe astratta come ancestor comune si utilizza un interfaccia, ma la filosofia è sempre la stessa.
Alcuni esempi di utilizzo di questo pattern sono le classi java.lang.Process e java.io.File della libreria standard.

5) Attivare o disattivare il debug.

L'abilitazione/disabilitazione del debug dipende dal framework di logging che si utilizza. I più famosi sono due:

Java Logging framework
Log4J

Entrambi permettono di attivare/disattivare il logging del debug sia attraverso i file di configurazione oppure per via programmatica.

Quello che non si può fare in Java

Come si è visto i problemi affrontati con il preprocessore in C/C++ sono in Java sono risolti in altra maniera. Questo non vuol dire che le soluzioni sono equivalenti. Ad esempio in Java non è possibile escludere una parte del codice dalla compilazione. Non è neanche possibile definire macro.
In genere la mancanza di queste caratteristiche non si sente. Se si sente questo potrebbe indicare che Java potrebbe non essere il linguaggio giusto per il problema in esame.
Se uno non può proprio fare a meno del preprocessore in rete ci sono progetti che estendono il linguaggio aggiungendo funzionalità simili. L'adozione di questi strumenti dovrebbe essere fatta responsabilmente perché può portare a dover mantenere codice scritto in un linguaggio Java modificato che quindi diventa meno accessibile perché meno conosciuto.

Nota: costanti e funzioni inline

Anche se in molti progetti scritti in C o C++ capita che il preprocessore sia usato per definire costanti o funzioni inline questo non vuol dire che sia una buona pratica. In questi casi la cosa migliore e fare uso delle parole chiave const e inline entrambe disponibili sia in C che in C++.

Macross Frontier

2008-06-03T22:16:00.005+02:00

Vi ricordate Macross? Sicuramente no. In Italia è uscita la serie ultra rieditata dagli americani chiamata Robotech, era in onda su Rete 4 anni fa e, nonostante fosse un cartone di culto, è stato trasmesso per poco tempo. Comunque vi spiego tutto io. Nel lontano millenovecentoambaradam in giappone creano una serie tv chiamata Chō Jikū Yōsai Makurosu. Qualche tempo dopo (nel millenovecentoambaradampiùenne) in America la Harmony Gold dice: "Che figata! La voglio anch'io.", però invece di fare semplicemente il doppiaggio decide di rieditare tutta la serie. Gli sceneggiatori dell'Harmony Gold, che pare avessero appena scoperto il copia e incolla, decidono di tagliare alcune scene, spostarne altre e di riscrivere totalmente i dialoghi. Risultato: Robotech, un prodotto che mantiene gli stessi robottoni della serie orginale ma dove gli aspetti più trascinanti della storia sono snaturati. La serie sbarca in Italia assieme a Beautiful, il Tenente Colombo e tutte le altre serie che importiamo dagli stati uniti. Così a noi ci è giunta la serie scrausa americana. Dopo un po' i fan rompono gli zebedei e ci è arrivata pure la serie doppiata dall'originale giapponese. A questo punto in giappone han visto che la serie tirava e han pensato bene di farne dei seguiti per capitalizzare sul nome conquistato dal prodotto. Fioriscono i seguenti titoli:

The Super Dimension Fortress Macross: Do You Remember Love?
The Super Dimension Fortress Macross: Flash Back 2012
The Super Dimension Fortress Macross II: Lovers, Again
Macross Plus
Macross 7
...
e altri ennemila altri titoli che neanche quelli che li hanno prodotti si ricordano bene quali sono.

L'ultimo titolo è Macross Frontier è quello che sto guardando adesso, ho visto solo fino alla quarta puntata. Fine della storia.

Schermare le RemoteException

2008-05-31T22:31:00.007+02:00

Consideriamo un'applicazione architettura client server basata su RMI. Il client deve accedere dialoga con il server usando l'interfaccia remota di quest'ultimo. Per fissare le idee supponiamo che il server abbia la seguente interfaccia:

public interface League extends Remote {
    void addTeam(String name) throws RemoteException;
    void removeTeam(String name) throws RemoteException;
    List<String> getTeamList() throws RemoteException;
    int getTeamsCount() throws RemoteException;
}

Come richiesto da RMI, per ogni metodo è specificato che può sollevare una RemoteException. Le RemoteException dovrebbero essere gestita dal client, ovvero le chiamate dei metodi dovrebbero essere racchiuse in un blocco try/catch come il seguente:

    TeamManager manager = ...;
    try {
        n = manager.getTeamsCount();
    } catch(RemoteException ex) {
        // gestione dell'eccezione
    }

Se le chiamate al server sono sparse in varie parti del codice del client la gestione delle eccezioni potrebbe diventare tediosa e ripetitiva. Utilizzando la tecnica descritta di seguito è possibile concentrare la gestione delle RemoteException in un unico punto. L'idea è quella di interfacciare il codice client con interfaccia simile a quella remota che però non richieda la gestione delle RemoteException, nel nostro caso:

public interface LocalLeague {
    void addTeam(String name);
    void removeTeam(String name);
    List<String> getTeamList();
    int getTeamsCount();
}

La soluzione si basa sul concetto di adapter. Creiamo un oggetto 'adapter' che implementa l'interfaccia locale e delega le chiamate al server remoto. La gestione delle RemoteException e gestita dall'adapter che di fatto le intercetta prima che possano arrivare al client. La situazione che si vuole ottenere e schematizzata in figura.

Il client utilizza l'interfaccia semplificata (senza RemoteException). L'adapter inoltra le chiamate al server, e nel caso gestisce la RemoteException catturandola prima che arrivi al client. Dato che il client richiede comunque una risposta nel caso di un'eccezione l'adapter interroga un oggetto fallback che fornisce il valore da restiuire in questi casi. Nel nostro caso l'oggetto di fallback è il seguetne:

LocalLeague fallback = new LocalLeague() {

    public void addTeam(String name) {
        // nothing
    }

    public void removeTeam(String name) {
        // nothing
    }

    public List<String> getTeamList() {
        return Collections.emptyList();
    }

    public int getTeamsCount() {
        return 0;
    }
};

In oltre l'adapter è in grado di segnalare le eccezioni interfacciandosi con un oggetto ExceptionListener. L'interfaccia ExceptionListener è definita nel package java.beans nel seguente modo:

public interface ExceptionListener {
    void exceptionThrown(Exception e);
}

Fornedo la propria implementazione di ExceptionListener il client può gestire tutte le RemoteException in un unico punto. La creazione dell'oggetto adapter avviene nel seguente modo:

LocalLeague adapter = AdapterFactory.adapt(LocalLeague.class,
                                           remoteServer,
                                           fallback,
                                           exceptionListener);

Potete scaricare la libreria che contiene queste funzionalità da http://code.google.com/p/andreafrancia-util/.

Syntax Highlighter

2008-05-27T00:38:00.009+02:00

Ho installato un plugin sul mio blog che dovrebbe effettuare l'highlight syntax del codice che scrivo nel blog. Proviamo. Scrivendo: <pre name="code" class="java:nogutter:nocontrols"> /* Commento */ int variabile = pinkElephant.getNumberOfFoot(); assert variabile == 4; System.out.println("Bella lì"); </pre> Ottengo:

/* Commento */
int variabile = pinkElephant.getNumberOfFoot();
assert variabile == 4;
System.out.println("Bella lì");

I rigraziamenti vanno ai signori che hanno scritto la libreria SyntaxHighlighter e al signore che si è preso la briga di creare il corrispondente plugin per Blogger .

Java Web Start

2008-05-26T02:35:00.003+02:00

Java Web Start è una tecnologia per la distribuire di applicazioni Java. Usando Web Start l'installazione si riduce al cliccare su un link o su un bottone in una pagina web. In questo articolo spiego come si usa questa tecnologia.

Usabilità di Sourceforge

2008-05-22T14:12:00.004+02:00

C'e' un gestore dei task associato al progetto. Bene.

Il mio progetto è piccolo, voglio aggiungere pochi task.

Posso aggiungerli? No!
Devo prima creare un subproject? Perché?

Creo il subproject.
Ci ripenso, voglio cambiare il nome, posso? No!

Quanto è complicato pubblicare una release su Sourceforge e su Google Code

2008-05-20T23:38:00.011+02:00

Ho due progettini opensource, uno si chiama bluetrash e sta su Sourceforge, l'altro si chiama remoted-list e sta su Google Code.

Per farvi capire la differenza di usabilità tra i due siti vi spiego come si rilascia un nuovo pacchetto su entrambi i sistemi.

Caso Google: remoted-list.
- faccio login su google code
- vado sulla pagina download del mio progetto
- clicco "new download"
- clicco Browse
- seleziono il file remoted-lists-0.0.2.jar dal mio disco
- clicco su submit file
- fine

Caso Sourceforge: bluetrash.
- vado sulla pagina download.
- cerco il bottone "aggiungi nuova release"
- non lo trovo
- cerco meglio
- trovo File Releases tra una delle 20 voci del menu Admin
- lo clicco
- Appare la pagine File Release System, quasi ci sono
- hai definito un package? se non l'hai definito non puoi proseguire!
- ok lo definisco
- attento se cambi idea il package una volta aggiunto non puoi rimuoverlo, puoi solo marcarlo hidden!
- va be' fa niente, alla fine ne ho due bluetrash (errore marcato hidden) e trash (giusto)
- C'e' un link Add Release per ogni package (anche per quello hidden).
- Scelgo "trash" quindi devo cliccare il link Add release di trash.
- appare un paginone composto da quattro capitoli "Step 1", 2 , 3 e 4.
- Allo step 1 mi chiede il nome della release, ok lo inserisco trash-0.1.8
- mi chiede ancora "Of which package" con scelta predefinitta "trash". Ma se te lo detto prima!
- mi chiede il changelog, e il Release note, io non ce li ho, non li ho fatti e non li metto
- clicco i l bottone update
- Vado più sotto nel documento a leggere allo Step 2
- Mi dice che devo fare l'upload del file file. Ok dov'e il bottone browse per scegliere il mio file sul file system? Non c'e'.
- C'e' scritto che posso caricare il file con SFTP, webdav o rsync. Per me uno vale l'altro, a che mi serve scegliere?
- Decido che lo faccio con SFTP.
- Penso dimmi quelle quattro cose che mi servono l'indirizzo (hostname, path, username e password). Le avranno scritte qui... no! non ci sono. bisogna cliccare il link.
- clicco il link che apre la pagina di help.
- Scopro hostname, path, username e password.
- faccio l'upload del primo dei tre file.
- Pero' io non voglio mettere sempre la password, posso installare la mia chiave pubblica ssh? No! non si puo'! vabbe'.
- Ripeto per gli altri due file mettendo la password a mano e rinunciando al pensiero di automare un giorno la cosa con qualche script.
- Torno sulla pagina, naturalmente non è aggiornata. Devo cliccare il bottone "Add Files and/or refresh view".... che cosa fa questo bottone? Aggiunge file oppure o anche aggiorna?
- Lo clicco
- appaiono i nomi dei file che caricato: trash-0.1.8-1.noarch.rpm, trash_0.1.8-2_all.deb, trash-0.1.8.tar.gz.
- finito? no!
- bisogna spuntare ognuno dei file e poi cliccare di nuovo il bottone omnicomprensivo : "Add Files and/or refresh view"
- Lo step 4 si popola di 3 righe, una per ogni file.
- Per ogni riga devo scegliere tipo di processore, data di rilascio, tipo di file.
- Ok li scelgo tutti poi schiaccio uno dei bottoni "update/refresh" (anche in questo caso i bottoni fanno piu' di un lavoro).
- Scopro che mi ha tenuto solo le scelte del file per cui ho premuto il bottone e le altre scelte sono andate perse.
- Ok ho capito devo modificarne e fare l'update/refresh di un file alla vota.
- finalmente
- finito.

http://www.visual.paginegialle.it/on_the_road/pavia

2008-05-17T15:30:00.001+02:00

Avete visto On the road di pagine gialle? Impressionante. http://www.visual.paginegialle.it/on_the_road/pavia

RemotedList

2008-05-14T22:11:00.016+02:00

I want to create a library to solve a problem which happens to me very often working with RMI and JPA. Consider having a remote server object with an interface like this:

public Server implements Remote{
    List<Foo> getFoos() throws RemoteException;
}

According to the the RMI specification calling this method will cause that the resulting List is serialized and passed back over the network to the client. Consider the case when the resulting list is huge and you don't want pass such a big thing over the network or consider the case when the list is not serializable. My remoted-list library will address these problems replacing a the actual list with a remoted version that lazily load the elements. The usage of remote-list is simple. Consider the getFoos() implementation:

List<Foo> getFoos() {
   List<Foo> actualList = ... // create or get a list according your business logic
   List<Foo> remotedList = RemotedList.remotize(actualList);

   return remotedList;
}

Instead to returning the actualList the method returns a remotedList which reflects the contents of the actualList mantaining a remote reference to actualList. The remoteList is also Serializable and ligth to serialize because it contains only a remote reference to the actualList instead to contains all reference of all elements. Now consider the client which retrieve the remotedList from the remote object.

remotedList = server.getFoos();
...
element = remoteList.get(index);

When the client call remoteList.get(index) the remoteList acts like a proxy and call through RMI the get(index) method on the actualList which was left on the server JVM. This is the idea. Soon I will prepare the library and I will release it for you all! UPATE 2008-05-15 I wrote the code and I put it online throuh Google Code. The project is hosted at http://code.google.com/p/remoted-list/.

Visit to Agliè Castle

2008-05-11T00:48:00.004+02:00

English (short): Today, I and my friend Elisa went to Agliè Castle in Piedmont which is also known because is one of the location of the Italian fiction "Elisa di Rivombrosa". The foto we take are availables on my picasa space: http://picasaweb.google.it/andrea.francia/20080511CastelloDiAgliConElisa Italiano (completo): Oggi, io ed la mia amica Elisa siamo andati al Castello di Agliè in Piemonte conosciuto anche per essere una delle location di "Elisa di Rivombrosa". Il castello è interessante, peccato che l'80% delle sale non si poteva vedere perché lo stavano restaurando. Stavano restaurando tutto! Anche nelle sale che si poteva visitare capitava che la guida dicesse: "In questa sala c'era un mobile bellissimo che però oggi non potete vedere perché lo stanno restaurando". Eh vabbe'. Ho messo le foto che abbiamo fatto sul picasa: http://picasaweb.google.it/andrea.francia/20080511CastelloDiAgliConElisa

Libreria per il parsing della linea di comando (args4j)

2008-05-06T23:33:00.004+02:00

L'altro giorno ho trovato finalmente una libreria che aiuta a fare il parsing della linea di comando. La libreria a cui mi riferisco è arg4j. È una libreria open source (MIT License), creata da Kohsuke Kawaguchiche tra l'altro è il creatore di Hudson (il sistema di continous integration che usiamo attualmente in azienda). Funziona sia con le opzioni corte (es. -R) che con quelle lunghe (--recursive). Non usa lo stile GNU delle opzioni, quindi non potete usarlo per fare il parsing di qualcosa come rm -Rfv Ma riesce solo a fare il parsing di cose come: rm -R -f -v Oltre a fare il parsing genera il messaggio di help per l'utilizzo delle opzioni direttamente dalla definizione delle opzioni.

Builder with fluent interface in Java

2008-05-04T19:02:00.003+02:00

Ho creato una libreria che semplifica la creazione Fluent Builders. La libreria su un idea di Stephan Schmidt che ho ampliato e modificato. La libreria permette di creare un builder con interfaccia fluent senza scrivere codice ripetitivo. La libreria permette di riscrivere il codice seguente:

Person person = new Person();
person.setFirstName("John");
person.setLastName("Smith");
person.getLovedThings().add("pizza");
person.getLovedThings().add("soccer");
person.getLovedThings().add("jogging");
person.setAge(30);

nel seguente modo:

Person person2 = Person.builder()
       .withFirstName("John")
       .withLastName("Smith")
       .withLovedThings("pizza", "soccer", "jogging")
       .withAge(30)
       .build();

Maggiori dettagli li trovati sul mio sito: Fluent Builder Library

Large File Viewer

2008-04-16T23:26:00.005+02:00

Ho scritto un articolo su come creare in Java un visualizzatore di grandi file di testo, cioé di dimensioni superiori al gigabyte. Lo messo qua: http://www.andreafrancia.it/articoli/large-file-viewer.html.

Nanà supergirl

2008-02-23T15:47:00.002+01:00

Ve la ricordate? Pian piano mi sto rivedendo tutta la serie. Gli episodi non sono tanti, si tratta di solo 39 puntate. Il cartone è molto ben fatto, lo stile del disegno è molto bello. Le storie sono semplici, alla portata di un pubblico non adulto, ma non eccessivamente infantili. Gli episodi sono sceneggiati bene e la comicità è immediata. Insomma una bel cartone, di qualità e adatto ai più piccoli. Sapevate che Nanà è creato dallo stesso gruppo che ha creato Pollon?

Crop Circles

2008-02-13T10:04:00.000+01:00

Gli alieni esistono e ci hanno lasciato un messaggio.

Basta fare il pendolare!

2008-01-26T19:14:00.001+01:00

Da gennaio la mia azienda si è trasferita a Pavia. Questo vuol dire che non farò più il pendolare per andare al lavoro. Basta ritardi dei treni e basta multe perché mi dimentico di fare l'abbonamento. Questa è la strada che devo fare ogni mattina :)
View Larger Map

L'ADSL se ne è andata

2007-12-18T13:50:00.000+01:00

Il giorno 12 dicembre 2007 è arrivata l'ADSL. Il giorno 17 dicembre 2007 l'ADSL ha smesso di funzionare. Che record! Ben (ironico) 5 giorni di funzionamento prima del primo inconveniente tecnico. Ho chiamato l'assistenza, mi dicono che "Ci sono problemi sulla linea.". Aspetto speranzoso che vengano risolti. PS alle 19.33: Stasera quando sono tornato si è rimessa a funzionare! L'allora l'assistenza serve a qualcosa ...

E' arrivata l'ADSL

2007-12-12T14:32:00.000+01:00

Finalmente è arrivata l'ADSL a casa. Sono finiti i tempi bui, adesso sarò connesso 24 su 24. Ho preso una ADSL flat a 4 mega di Wind. Ho scelto Wind perché era la più economica. Mi hanno dato anche la linea fissa. Stamattina mi è arrivata la notifica via mail di Wind che l'ADSL è attiva , oggi sono andato a comprare il modem e il filtro. Stasera appena torno a casa sarò connesso.

Foto di Dublino

2007-11-06T13:42:00.000+01:00

Ho messo online le foto di Dublino. Le trovate all'indirizzo http://picasaweb.google.it/andrea.francia/Dublin2007 Non ho messo on-line tutte le foto che ho fatto, ho cercato di ridurle per non annoiarvi troppo.

Dublino

2007-10-29T16:46:00.000+01:00

Oggi posto direttamente da Dublino. Nonostante quello che qualcuno voleva farmi credere la città è molto bella. Apprezzo soprattutto la possibilità di incontrare gente (e soprattutto ragazze) di tutte le nazionalità ... tra argentini, italiani, brasiliani e polacchi, abbiamo trovato anche qualche irlandese. La città è ospitale, i prezzi non sono cosi alti come mi aspettavo e ci sono parecchie cose da vedere. Lo stile architetturale del centro mi piace molto, le case piccole con le porte di ingresso colorate con le colonne ai lati mi piacciono tantissimo. Anche la cucina è ottima. La vita notturna inizia e finisce presto a Dublino, una buona cosa per i "vecchi" come me a cui non piace dover aspettare fino alle 24.00 per trovare qualcuno in discoteca. Qui le discoteche aprono alle 10 e chiudono alle 2.30. Se vuoi iniziare ancora prima puoi trovarti alle 6 pm per una birra in un pub e tirare fino a notte. Purtroppo non sembra che ci siano dei buoni posti per ballare la salsa, pochi posti e affollati. Il tempo all'internet cafè sta scadendo ... ciao a tutti.

Dublino

2007-10-22T13:48:00.001+02:00

Tra poco vado in vacanza :) Venerdì questo (26 ottobre) parto per Dublino ci starò 10 giorni, fino a domenica 4 novrembre 2007! Ciao a tutti :)

Foto della Biennale

2007-08-26T16:36:00.001+02:00

Ho messo online le foto che ho fatto ieri alla Biennale di venezia. Eccole: http://picasaweb.google.it/andrea.francia/BiennaleDiVenezia2007

Sabato alla Biennale

2007-08-23T22:32:00.001+02:00

Questo sabato (25 agosto 2007) vado alla Biennale, quella di Venezia naturalmente. Per ora siamo in due che vengono sicuro e un'altra persona che mi deve ancora dire se viene o meno.

Foto a tradimento

2007-08-06T23:57:00.000+02:00

Ecco mi hanno fatto una foto mentre facevo una domanda stupida allo SMAU dell'anno scorso (era il 9 novembre 2006). La domanda non era stupida, in realtà ero troppo avanti rispetto ai tempi, era all'avanguardia e gli altri erano rimasti ancora allo studio della prospettiva.

Foto della Festa Hawaiana

2007-07-30T17:46:00.001+02:00

Ho messo online le foto della Festa Hawaiana.
http://picasaweb.google.it/andrea.francia/20070719FestaHawaiana/
Devo darvi il codice per vederle, chiedetemelo su messenger

Recycle Bin per Linux

2007-07-24T21:45:00.000+02:00

Ole! Finalmente l'ho finito! Un cestino a linea di comando per Linux. Si ricorda da dove hai cancellato il file e quando. E' interoperabile con il cestino di KDE, cioé se butti un file con questo programma poi lo ritrovi nel cestino di KDE. Download from http://bluetrash.sourceforge.net/. La foto non c'entra, ma è carina.

Google Pages

2007-07-21T15:26:00.000+02:00

Ho provato Google Pages. Comodo. Ecco il mio sforzo creativo: Moore Law Revisited

Toilet a Palazzo Reale

2007-07-18T23:17:00.000+02:00

A sinistra potete ammirare le splendide toilette artistiche davanti a Palazzo Reale. Se ve lo state chiedendo ... Sì dentro sono come tutte gli altri bagni portatili.

Chiuso fuori!

2007-07-16T16:50:00.000+02:00

OSSEC è un HIDS, un Host-based Intrusion Detection System ... Lo installi, lo avvi e lui comincia a controllare i log e altri file sulla macchina e capisce se qualcuno ti sta attaccando ... L'ho provato ... Funziona ! ... Troppo pero' ... Appena l'ho avviato ha deciso di bannare il mio IP ... penso che confonda il mio accesso a Subversion via HTTP con qualche attacco e di conseguenza aggiunge una regola al firewall che mi chiude fuori, qualcosa del tipo -A IL.MIO.IP.ADD -J DROP Ehi!! ti sei chiuso dentro!! All'inizio avevo dato la colpa a Snort un IDS che stavo provando assieme a OSSEC. Adesso ho scoperto come mettere la mia macchina nella white list e OSSEC non mi lascia piu' sulla porta.

Andando in Piazza

2007-07-13T17:43:00.000+02:00

Era un po' che avevo cominciato "ad andare in piazza" A Cesare Ragazzi non ci crede piu' nessuno ... Ma la soluzione c'e' ! Far finta che l'hai deciso tu ... e rasare tutto. Comunque si vede che non avrei potuto scegliere ... Pero' così sto meglio :-)

WinMerge

2007-07-11T22:55:00.000+02:00

Licenza: GPL Ambiente: Windows Confronta due file di testo. Come il comando diff sotto Unix, solo che il confronto è visuale. Come WinDiff di Visual Studio solo che funziona meglio. Supporta l'highlight syntax per un molti linguaggi. Confronta directory in modo ricorsivo. Si può configurare per ingnorare i file ausiliari di CVS e Subversion. Permette di modificare i file che si stanno confrontando. Utilissimo per lo sviluppatore. http://winmerge.org/

FilZip

2007-07-11T22:42:00.000+02:00

Basta usare WinZip! Non potete usarlo senza pagare la licenza, anche se funziona lo stesso. E poi cosa lo usate a fare che da Windows XP i file .zip ve li apre Explorer? Sì, ok è lentissimo. WinRar e WinAce? Anche loro a pagamento. Se volete continuare ad aprire gli archivi e essere in regola senza pagare usate FilZip che è gratuito. Estrae anche gli archivi RAR . http://www.filzip.com/

Referendum sulla legge elettorale

2007-07-11T14:09:00.000+02:00

Avete presente la "porcata" di Calderoli. Mi riferisco alla legge elettorale votata alla fine dell'ultima legislatura. Sembra che a molti questa legge non piaccia e c'e' chi vorrebbe cambiarla. Da un po' si stanno raccogliendo le firme per il referendum. Io me ne sono accorto solo adesso perché sono lento a seguire la Politica. Io non ho ancora chiaro che cosa voterò se e quando ci sarà il referendum. Però penso che andrò a firmare per il referendum. Se volete firmare per il referendum dovete rivolgervi al vostro comune di residenza. Va bene anche un altro comune ma è meglio quello di residenza, firmando in un altro comune si rischia che la vostra firma non sia registrata in tempo.

Il Libro delle Antiche Invezioni

2007-07-10T21:09:00.000+02:00

Ho appena finito di leggere questo libro, mi è piaciuto molto. Sono 670 pagine ! Non vi siete mai chiesti "Ma come facevano a chiamarsi quando non esisteva il cellulare?" Beh questo libro va un po' oltre. Dopo averlo letto ti rendi conto di quanto fosse simile la nostra vita quotidiana a quella degli antichi. Ti rendi conto di quanto i nostri antenati fossero intelligenti, che trovavano soluzioni a problemi che oggi crediamo che non siano risolvibili senza un computer, la plastica, o la catena di montaggio. http://www.deastore.com/product.asp?productid=IE776905&cookie%5Ftest=1

Mostra su Botero a Milano

2007-07-10T20:57:00.001+02:00

Avete presente quei quadri con i personaggi grassi grassi grassi? Li fa un signore che si chiama Botero e che abita a Pietrasanta (Toscana) http://www.turismo.comune.milano.it/pls/milano/!dettaglio?lang=2&evento_id=285511 Io probabilmente ci vado giovedì sera...

Hello World

2007-07-10T20:13:00.000+02:00

Ecco il primo post di un programmatore.