Category: programming

  • Aggiornare tutti i package Python installati con pip

    Per aggiornare tutti i package Python installati, suggerisco di usare pip nel seguente modo:

    1. Aggiorno pip all’ultima versione (suppongo di avere easy_install): easy_install -U pip
    2. Estraggo la lista dei pkg installati e li aggiorno uno per uno: pip freeze --local | cut -d = -f 1 | xargs pip install -U
  • Come mandare un segnale SIGINT (Ctrl-C) ad un programma che gira nella console di Eclipse

    Quando si sviluppa un programma che deve girare ininterrottamente nella console, non ci sono problemi se si lancia il programma da console e lo si termina tramite la più classica delle combinazioni: Ctrl-C. Ma come si termina lo stesso programma se lo si è lanciato da Eclipse?

    Si deve lanciare un segnale al processo, e più in particolare un SIGINT (interruzione): apriamo una console:

    kill -s INT pid

    o, se usiamo pkill:

    pkill -s INT <nome dell’interprete che sta runnando il programma: Java, Ruby, Python, etc.>

  • Installare più plugin contemporaneamente su Eclipse

    Installare più plugin contemporaneamente su Eclipse

    Eclipse è il mio IDE preferito per tutti gli sviluppi. Per migliorare le funzionalità di Eclipse, utilizzo alcuni plugin che semplificano il processo di sviluppo (ma dei plugin che utilizzo ve ne parlerò in un altro post). Un piccolo accorgimento che mi è stato utile è quello di installare più plugin contemporaneamente (dopo l’installazione di un plugin, Eclipse richiede un riavvio):

    1. Create un account su Eclipse Marketplace;
    2. Una volta loggati su MarketPlace, cercate i plugin che volete installare e marcateli come favorite
    3. Andate in “My MarketPlace” e copiate Update Site URL
    4. In Eclipse, andate su Help -> Install New Software e usate l’URL appena copiato come repository di installazione

    Nel repository potete trovare tutti i plugin marcati come favoriti e li potrete installare in una sola sessione di installazione: semplice e veloce!

  • FizzBuzz: una sfida per programmatori

    Un quesito che viene spesso richiesto ai programmatori è quello di scrivere un programma FizzBuzz:

    Write a program that prints the numbers from 1 to 100. But for multiples of three print “Fizz” instead of the number and for the multiples of five print “Buzz”. For numbers which are multiples of both three and five print “FizzBuzz”.

    La difficoltà principale, se così vogliamo chiamarla, è quella di leggere attentamente i requisiti e trasformarli in if condizionali del linguaggio scelto. Nel mio caso, Java:

    import junit.framework.Assert;
    
    public class FizzBuzz {
        public static void main(String args[]) {
            for (int i = 1; i <= 100; i++) {
                if (i % 3 == 0 && i % 5 == 0) {
                    System.out.println("fizzbuzz");
                    Assert.assertTrue(divisibleBy3(i) && divisibleBy5(i));
                } else if (i % 3 == 0) {
                    System.out.println("fizz");
                    Assert.assertTrue(divisibleBy3(i) && !divisibleBy5(i));
                } else if (i % 5 == 0) {
                    System.out.println("buzz");
                    Assert.assertTrue(!divisibleBy3(i) && divisibleBy5(i));
                } else {
                    System.out.println(i);
                    Assert.assertTrue(!divisibleBy3(i) && !divisibleBy5(i));
                }
    
            }
        }
    

    L’algoritmo si può complicare a piacere. In una curiosa implementazione, viene richiesto di non usare operazioni come la moltiplicazione e la divisione. L’autore del post risolve il problema utilizzando una coda circolare, sfruttando il fatto che i numeri seguono un comportamento periodico.
    Nel risolvere lo stesso problema, ho deciso di utilizzare un approccio diverso. Infatti, mi sono ricordato che esistono dei criteri per stabilire a priori se un numero è divisibile per determinati numeri (in particolare per 3 e per 5). E così ho scritto due metodi per testare se un numero passato come parametro è divisibile per 3 o per 5:

        public static boolean divisibleBy3(int num) {
            String s = new Integer(num).toString();
            while (s.length() != 1) {
                int j = 0;
                for (int i = 0; i < s.length(); i++) {
                    j += Integer.parseInt(s.substring(i, i + 1));
                }
                s = new Integer(j).toString();
            }
            if (s.equals("3") || s.equals("6") || s.equals("9"))
                return true;
            return false;
        }
    
        public static boolean divisibleBy5(int num) {
            String s = new Integer(num).toString();
            String lastDigit = s.substring(s.length() - 1, s.length());
            if (lastDigit.equals("5") || lastDigit.equals("0"))
                return true;
            return false;
        }
    }
    

    E applicarlo al FizzBuzz è un’operazione elementare.

  • django: come fare il deploy di un’applicazione su Apache

    Una volta che avete terminato lo sviluppo di un’applicazione basata su django, è il momento di installarla in produzione. Nel mio caso, ho utilizzato django 1.3.1 e ho scelto di utilizzare Apache e mod_wsgi. Vediamo come fare il deploy passo-passo:

    • Fortunatamente mod_wsgi richiede Apache mpm-worker (anziché il meno performante prefork) che su Debian/Ubuntu è facilmente installabile tramite sudo apt-get install libapache2-mod-wsgi
    • Spostiamo l’applicazione sotto un path di sistema, tipo /usr/share/app
    • Aggiungere a /etc/httpd.conf la direttiva WSGIScriptAlias / /usr/share/app/django.wsgi dove il primo parametro (/) rappresenta il path a cui django dovrà rispondere (in questo caso la root), mentre il secondo parametro rappresenta un file che scriveremo nel prossimo step, e che descrive a WSGI come interpretare l’applicazione django che abbiamo scritto
    • Aprite il file che abbiamo definito al punto precedente (django.wsgi) e inserite il seguente codice Python:
      “`
      import os
      import sys
      import django.core.handlers.wsgipath = '/usr/share/app'
      if path not in sys.path:
      sys.path.append(path)

      os.environ['DJANGO_SETTINGS_MODULE'] = 'app.settings'

      application = django.core.handlers.wsgi.WSGIHandler()
      “`

      Ricordatevi di settare correttamente il path e i settings (che corrisponde al settings.py di django)

    • Riavviare apache: service apache2 restart

    Aprite il browser andando a settare l’URL in corrispondenza di quanto definito al punto 1 di questo tutorial (il context-path) e controllate che sia tutto a posto (diversamente, controllate l’error log di Apache).
    Una soluzione aggiuntiva sarebbe quella di introdurre un reverse proxy (scelta personale: nginx) davanti ad Apache per servire i files statici (js, css, png, etc.). Ma questo sarà un altro post.

  • AJAX per applicazioni web: la mia recensione

    ajax_applicazioni_web

    Nell’epoca del Web 3.0 ho letto questo libro che tratta (a grandi linee, come vi spiegherò tra poco) di AJAX, la enabling technology del Web 2.0.

    Ma cos’è AJAX? È un insieme di tecnologie (tra cui Javascript e XML) che permettono lo scambio di dati tra client e server in modo asincrono, permettendo di realizzare le cosiddette RIA (Rich Internet Applications, come Gmail).

    Il libro è molto compatto (342 pagine) ed è composto da 12 capitoli. A mio avviso il libro è fin troppo generico e discorsivo; si dilunga infatti un po’ troppo sulla teoria tralasciando la parte pratica, a volte presentando listati di codice senza nemmeno spiegarli. Inoltre, ci sono alcuni capitoli in cui si assiste ad alcune divagazioni discorsive che non portano da nessuna parte (si introducono Python, Django, Ruby, Rails e PHP ma non vengono poi utilizzati). Solo nel capitolo introduttivo viene spiegato il funzionamento di xmlHttpRequest e come utilizzarlo: dopodiché, nel libro, non verrà quasi più menzionato.

    Il libro è utile a chi vuole ottenere una panoramica teorica delle tecnologie utilizzate per lo sviluppo web, ma non di più.

  • Linguaggio C, seconda edizione (K&R): la mia recensione

    In pochi giorni ho letto una pietra miliare dei libri della programmazione, il famoso K&R (dagli autori Kernighan & Ritchie); si tratta del libro più famoso per quanto riguarda la programmazione C.

    linguaggio_C

    In libro è molto breve (in totale 340 pagine, ma le ultime ~100 pagine di appendice sono una reference manual condensata). Il libro è adatto a chi ha già una buona base di programmazione, perché vengono presentati e implementati concetti non banali usando puntatori e struct. Tutti i concetti e i paradigmi del C sono sviscerati e spiegati all’utente. Nella parte finale del libro, vengono presentate anche le basi della programmazione C in ambiente UNIX.

    I due autori sono molto chiari e spiegano in modo molto approfondito le scelte tecniche e i paradigmi utilizzati.

    In definitiva, essendo un pilastro della programmazione, consiglio la lettura a tutti i programmatori: a mio avviso è un libro è indispensabile nella libreria di ogni programmatore.

  • require_relative in ruby 1.9 e la retrocompatibilità con ruby 1.8

    A partire da ruby 1.9 è obbligatorio utilizzare l’istruzione:

    require_relative 'pkg'

    affinché venga importato il modulo ‘pkg’ presente nella stessa directory in cui è presente il modulo che stiamo scrivendo. Mi spiego meglio: dato un modulo ruby detto ‘pkg’, se vogliamo importarlo in un altro file (chiamiamolo ‘foo’ per semplicità), dobbiamo scrivere:

    • in ruby 1.8: require 'pkg'
    • in ruby 1.9: require_relative 'pkg'
    Questo accorgimento è utilizzato per aumentare la security di chi scrive e soprattutto di chi utilizza programmi: nel caso in cui siano definiti più moduli ‘pkg’ (uno in gems e uno locale), quale dovrebbe importare l’interprete?
    La soluzione è assolutamente valida, ma richiede un po’ di manutenzione per garantire la retrocompatibilità con ruby 1.8. Infatti, per permettere a ruby 1.8 di interpretare correttamente l’istruzione ‘require_relative’ dobbiamo procedere ad un workaround dichiarando l’implementazione di tale istruzione:
    unless Kernel.respond_to?(:require_relative)
      module Kernel
        def require_relative(path)
          require File.join(File.dirname(caller[0]), path.to_str)
        end
      end
    end
    

    A questo punto è sufficiente utilizzare require_relative anche in ruby 1.8 per non avere più problemi.

  • gitignore: un filtro per escludere i file da non versionare in un repository git

    Prima di fare un push su un repository git è importante avere configurato il gitignore, ovvero specificare quali files non devono essere versionati in un repository git. A titolo di esempio: i file .pyc, o più in generale i prodotti della compilazione di un qualsiasi file di sorgente; versionare questi files, infatti, non ha senso.

    Per fare in modo che git eviti di versionare certi tipi di files, creiamo un file .gitignore dentro la nostra $HOME, ed  il gioco è fatto. Se volete partire da un esempio già realizzato, includo qui il mio gitignore.

    michele@delta:~ % cat ~/.gitignore
    # Compiled source #
    ###################
    *.com
    *.class
    *.dll
    *.exe
    *.o
    *.so

    # Packages #
    ############
    # it’s better to unpack these files and commit the raw source
    # git has its own built in compression methods
    *.7z
    *.dmg
    *.gz
    *.iso
    *.jar
    *.rar
    *.tar
    *.zip

    # Logs and databases #
    ######################
    *.log
    *.sql
    *.sqlite

    # OS generated files #
    ######################
    .DS_Store*
    ehthumbs.db
    Icon?
    Thumbs.db

  • PHP5 e MySQL, la guida: la mia recensione

    php_mysql_guida

    Per ripassare le mie nozioni di PHP5, ho deciso di leggere il libro di McGraw-Hill, “PHP5 e MySQL, la guida“, composto da circa 1100 (!) pagine. Perché proprio PHP? Peché, PHP è un linguaggio di successo, sebbene non venga presentato nei migliori dei modi (“è un linguaggio per principianti”). Ecco almeno 4 ragioni per cui conoscere PHP è un plus:

    1. è attualmente il quarto linguaggio più diffuso in termini di codebase OSS;
    2. il più utilizzato e diffuso social network lo utilizza (anzi, lo migliora!);
    3. i CMS più famosi (WordPress e Drupal) sono sviluppati in PHP;
    4. sapevate che anche Wikipedia lo utilizza?
    Passiamo al libro: la lettura non è molto agevole (ci sono errori di battitura, traduzioni forzate dall’inglese, snippet di codice senza alcun syntax highlighting [non parlo del colore, ma almeno del bold!]) ma tutto sommato riesce a spiegare esaurientemente bene tutte le peculiarità di un linguaggio di successo quale PHP.
    Il libro passa in rassegna ogni aspetto del linguaggio, quali:
    • le basi del linguaggio
    • i tipi e la OOP con PHP5
    • la connessione ai database MySQL/PostgreSQL/Oracle
    • il package manager PEAR
    • l’utilizzo di sessioni e cookie
    • l’implementazione di servizi REST e SOAP

    Il libro termina con una serie di esempi svolti e analizzati. In definitiva il libro è un ottimo manuale per imparare (da zero) il PHP. In alcuni punti è spesso prolisso e ripetitivo; rappresenta tuttavia una buona miniera di informazioni e di reference per quando si deve sviluppare in PHP. La parte relativa all’approfondimento relativo all’integrazione con i database è lasciata a 3 capitoli (sebbene molti esempi siano presenti in tutto il libro); soluzione che ritengo comprensibile, visto il proliferare di ORM (come Doctrine) che “nascondono” i tweaking un tempo necessari per la connessione al db).

    In definitiva, un libro buono, ma non indispensabile: esistono libri più economici (e soprattutto più compatti!) che permettono di ottenere la stessa infarinatura di PHP.