SlashCode » guida

Digital Mind: Nuovo Update!

THeK3nger — Sun, 18 Apr 2010 10:39:29 +0000

Segnalo ancora un nuovo aggiornamento. Arrivato in ritardo ma è arrivato. Purtroppo sono stato distratto da interessanti argomenti di Intelligenza Artificiale e mi è passato tutto il resto di mente!

Fra le modifiche che ho fatto segnalo che ho completato la parte sui modelli astratti di algoritmi (forse approfondisco un po’ le macchine a registri) e ho corretto alcune sviste.

Ecco il solito link:

DIGITAL MIND

Alla prossima.

SlashCode Reloaded

THeK3nger — Mon, 22 Mar 2010 13:41:19 +0000

Penso di dover dare conto a qualcuno della mia lunghissima assenza. Ci sono molti motivi che mi hanno tenuto lontano dalle pagine di SlashCode in questi mesi. La prima è che avevo bisogno di staccare un attimo dalla vita tecnologica per dedicarmi ad altre mie passioni come la musica e la letteratura. Suono il pianoforte e la chitarra da anni e ultimamente le stavo lasciando troppo decadere. Il secondo punto è che, non appena ho ripreso gli studi informatici, mi sono concentrato su argomenti che sono poco da blog o quantomeno necessitano di una preparazione più specifica da parte del lettore e di un laborioso processo di semplificazione da parte mia. Ne parlerò sicuramente in un prossimo futuro ma essendo cose completamente nuove ci metto un po prima di elaborare un pensiero organico e coerente.

Il terzo punto invece è molto più interessante per chi mi legge. In questi mesi ho scritto gran parte di un libro dedicato a chi si avvicina alla programmazione ma anche a chi, sebbene sappia già programmare discretamente, è interessato al lato più “ingegneristico” e scientifico dell’informatica. Questo libro nasce per sostituire il vecchio GaPG la cui impostazione “blogghistica” cominciava da un lato a non soddisfarmi e dall’altro a limitare la mia possibilità di approfondire alcuni degli argomenti in modo coerente.

Prima di pubblicare la versione pdf ho preferito iniziare a rendere disponibile una versione HTML (raggiungibile da qui) che aggiornerò con cadenza circa settimanale. Ho optato per l’html in quanto mi è più facile mantenere aggiornata una versione web piuttosto che generare decine di bozze pdf con il rischio che le persone non sappiano più quale sia l’ultima versione aggiornata.

L’intero libro parte da un presupposto. La matematica. Non sono necessari prerequisiti matematici elevati: basta sapere un po di teoria degli insiemi e le operazioni base. Tuttavia non potevo farne a meno: chi parte con l’idea di programmare (e per programmare intendo farlo seriamente) deve mettersi in testa che la matematica è un requisito fondamentale.

Il volume è attualmente in lavorazione e, sebbene metto online solamente le parti che sono state già revisionate, non sono certo che siano esenti da errore ne che per adattarlo al resto faccia modifiche sostanziali sui primi capitoli.

Detto questo devo aggiungere due cose. Primo, il libro è dedicato a Evan (DJNeophyte) che mi ha incoraggiato a portarlo avanti anche quando pensavo di lasciar perdere. A lui va il più importante ringraziamento. Secondo, mi auguro che se siate interessati contribuiate con consigli di vario genere e segnalazioni di errori. Dopotutto possiamo considerarlo un libro opensource.

Alla prossima.

P.S.: Dato che non ho mai usato il LaTex per fare pagine Web mi sono arrangiato utilizzando il tool mk4ht. Solo che non l’ho mai usato. Se qualcuno volesse e conoscesse o lo strumento o il css e voglia contribuire a creare una versione web meno rustica mi contatti. Grazie.

Introduzione alle PyQT – Prefazione

THeK3nger — Sat, 07 Nov 2009 06:00:12 +0000

Verrei farvi un regalo apprezzato. Mettere in piedi un’altra serie di guide oltre alle altre due principali (GAPG e Scheme) rischia di essere un azzardo. Ma, dato che sicuramente da febbraio avrò moolto tempo libero e che “parallelizzare un processo porta quasi sempre benefici” ho deciso di preparare una “mini serie” sulla programmazione grafica e in particolare all’uso di Qt e Python.

PERCHÉ QT?

Le Qt, dal mio punto di vista, sono nettamente superiori alle Gtk per semplicità di uso, completezza, resa grafica e strumentazione. Inoltre le so usare molto meglio delle Gtk e quindi non rischio di dire troppe boiate. Terzo punto, le Qt sono stra-mega portabili e quindi questa guida può essere facilmente seguita anche da sviluppatori Win.

PERCHÉ PYTHON?

Le Qt sono nativamente scritte in C++ per ovvi motivi. Esistono wrapper per parecchi linguaggi ma, fra tutti, quello meglio riuscito è sicuramente quello per Python. Quindi, per non dovermi concentrare troppo su argomenti troppo tecnici ed estranei alle Qt di cui sarei costretto a parlare se usassi C++, ho scelto Python. Inoltre Python è facile ed è uno dei linguaggi di programmazione con cui molti nuovi arrivati cominciano a programmare.

Python è la scelta adatta. Inoltre da python vi sarà semplice passare al C++ in quanto sia i nomi delle classi Qt, sia i dati con cui lavoro sono pressocché identici.

REQUISITI

I requisiti per la guida sono:

Conoscenza di Python a livello medio o medio-basso (ovvero conoscere tutti i costrutti base tipo if, for, def, while, liste, dizionari, tuple, etc…)
Familiarità con la programmazione a oggetti.
Familiarità con il terminale.
Cenni di Makefile.
Cenni di bash.

STRUMENTI

Presenterò gli strumenti man mano che ci serviranno. Tuttavia la dotazione base che utilizzarò io sarà:

KDevelop (o un qualsiasi altro editor/IDE)
PyUIC4
Qt-Designer
PyLint

Oltre ad altre varie ed eventuali.

COSA TRATTEREMO

Gli argomenti si dislocheranno fra:

Esempio di primo programma in Qt.
Presentazione dell’architettura della libreria Qt.
Presentazione di alcuni Widget comuni.
I Layout.
Gestione degli Eventi
I widget personalizzati

Più altre cose che ancora non ho deciso. Ci metterò un po ad organizzarmi per bene il discorso.

CONCLUSIONI

Alla fine delle guida saprete costruirvi delle interfaccie più o meno complesse. Ovviamente non posso insegnarvi il senso estetico ma quello non mi sembra importante per ora.

Datemi qualche feedback. Se ci sono persone interessate comincio lo sviluppo altrimenti lo lascio nella lista delle cose pendenti.

C/C++ – Dichiarazione Avanzata dei Tipi

THeK3nger — Wed, 10 Dec 2008 08:54:40 +0000

Questo articolo prende spunto dal corso di Ingegneria degli Algoritmi e da un articolo di Steve Friedl sulla lettura delle dichiarazione di tipo.

Uno degli scogli principali per chi comincia a programmare in C è proprio quello di comprendere bene il significato dei vari * e delle funzioni più contorte. Non è inverosimile che per i principianti si sviluppi un metodo di programmazzione chiamato “proviamo e vediamo se funziona” che consiste nell’aggiungere asterischi a caso nella dichiarazione fino a quando il programma funziona come sperato.

Ovviamente questo metodo è sconsigliabile, contando che esiste una pratica regola che rende decifrabile anche le dichiarazioni più ingarbugliate: “go right when you can, go left when you must”

In italiano la regola suona più o meno: vai a destra finchè puoi, vai a sinistra quando devi. Ma come tutte le regole necessita di un esempio per essere afferrata.

Prendiamo una dichiarazione che farebbe impazzire chiunque:

char *(*(**foo [][8])())[];

“Oddio!” direte voi, ma manteniamo la calma. Il primo passo consiste nell’isolare il nome della variabile e il tipo base. Il nome della variabile è solitamente l’unica parola non riservata che trovate nella dichiarazione, nel nostro caso foo, mentre il tipo base è il tipo che si trova più a sinistra di tutti.

foo è un ... char

Ora dobbiamo riempire i puntini. Per prima cosa definiamo alcune semplici regole di lettura:

gli asterischi * si leggono puntatori a o puntatore a
le parentesi quadre [] si leggono array di
le parentesi numerate [x] si leggono array di x di
le parentesi tonde () si leggono funzione che restituisce
le parentesi tonde con parametri (x,y) si leggono funzione che prende come parametro x, y e restituisce

Con queste regole ora non ci resta che partire a seguire la regola principale cominciando dal nome della dichiarazione.

La prima cosa che troviamo andando a destra sono le parentesi quadre, quindi:

char *(*(**foo [][8])())[];

foo è un array di ... char

Continuiamo ad andare a destra (ricordiamoci il “a destra finchè posso”) e troviamo altre parentesi quadre.

char *(*(**foo [][8])())[];

foo è un array di array di 8 di ... char

A questo punto troviamo una parentesi chiusa, non possiamo quindi più andare a destra finchè non troviamo, a sinistra, la corrispondente parentesi aperta. Facciamo quindi un balzo a sinistra e intanto continuiamo a riempire i puntini. A sinistra troviamo due asterischi quindi:

char *(*(**foo [][8])())[];

foo è un array di array di 8 di puntatori a puntatori a ... char

Abbiamo trovato la parentesi. Adesso quindi ci è permesso andare a destra. A destra troviamo un paio di parentesi tonde.

char *(*(**foo [][8])())[];

foo è un array di array di 8 di puntatori a puntatori a funzione che restituisce
... char

Altra parentesi chiusa. Andiamo quindi a sinistra.

char *(*(**foo [][8])())[];

foo è un array di array di 8 di puntatori a puntatori a funzione che restituisce
puntatori a ... char

E cosi via finché non completiamo tutta la dichiarazione.

char *(*(**foo [][8])())[];

foo è un array di array di 8 di puntatori a puntatori a funzione che restituisce 
puntatori a array di... char

E cosi alla fine abbiamo che:

foo è un array di array di 8 di puntatori a puntatori a funzione che restituisce
puntatori a array di puntatori a char.

Abbiamo quindi decriptato con facilità una dichiarazione che sembrava impossibile. Ora, per vedere se avete capito e se siete bravi vi lascio una dichiarazione per esercizio:

int * ( (* (* foo) () ) [5][7]) ()

Buon divertimento!

Java – Multithreading

THeK3nger — Sat, 22 Nov 2008 08:24:08 +0000

Posto qui di seguito la prima di una serie di guide pratiche su Java e sul Multithread che sta portando avanti un mio amico di università Dymios sul suo blog. Per ora metto solo la prima parte. Potete continuare la lettura sul suo blog.

Multithreading in Java – di Dymios

Una normale applicazione che gira sulla nostra macchina ha un solo flusso di esecuzione: si dice che ha un singolo thread attivo. Con la tecnica del multithreading è possibile creare diversi flussi di istruzioni in esecuzione per una singola applicazione. In questo modo possiamo delegare un certo compito ad un thread mentre noi nel programma principale eseguiamo qualche altra operazione. Possiamo cioè effettuare più calcoli ed operazioni in parallelo.

Java offre due possibilità per fare questo, vediamole una per volta:

1) Estendere la classe Thread
Le operazioni da eseguire in un thread vanno scritte nel metodo run() di un oggetto che estende la classe java predefinita Thread. La classe chiamante dovrà creare un oggetto di tale classe ed invocare il metodo start(). La JVM a questo punto creerà il nuovo thread e invocherà il metodo run().

public class Main {
   public static void main(String args[]) {
      MioThread t = new MioThread();
      t.start();
   }
}

public class MioThread extends Thread {
   public MioThread() { ...costruttore... }
   public void run() {
      System.out.println("Sono il Thread t!");
   }
}

2) Implementare l’interfaccia Runnable
Metodo molto simile al precedente.

public class Main {
   public static void main(String args[]) {
      MioRunnable runnable = new MioRunnable();
      Thread t = new Thread(MioRunnable);
      t.start();
   }
}

public class MioRunnable implements Runnable {
   public MioRunnable() { ...costruttore... }
   public void run() {
      System.out.println("Sono il Thread t!");
   }
}

Programmazione #11 – Oggetti – Generalità

THeK3nger — Tue, 18 Nov 2008 17:15:45 +0000

Continuiamo la serie di lezioni sulla programmazione generale, questa volta cercando di approfondire molti degli aspetti che nelle prime 10 parti introduttive avevamo lasciato appesi. Cominciamo perciò dal concetto che (dopo i puntatori) spiazza di più chi non ha confidenza con la programmazione: gli oggetti.

Abbiamo già visto nelle parti precedenti il principio base su cui si fondano i linguaggi di programmazione orientati agli oggetti. In particolare abbiamo parlato del concetto di oggetto come del concetto di entità dotata di caratteristiche e abilità particolari.

Adesso cercheremo di entrare più in dettaglio su alcuni aspetti per ottenere le basi per futuri approfondimenti.

Dobbiamo innanzitutto tenere presente che un oggetto può essere visto da due punti di vista:

Il punto di vista esterno che corrisponde al modo in cui un oggetto viene visto dal mondo esterno, cioè da tutti gli oggetti all’infuori di se stesso.
Il punto di vista interno che corrisponde a come l’oggetto vede e interpreta se stesso.

Per chiarire un po la situazione considerate che l’interno di un oggetto è di interesse solamente per chi programma l’oggetto mentre il punto di vista esterno è di interesse per chiunque lo usi.

Struttura esterna di un oggetto.

Dall’esterno un oggetto è assimilabile ad una scatola sigillata. L’accesso e il funzionamento di questa scatola è garantito solamente dalle leve esterne chiamate metodi. L’insieme dei metodi esterni prende il nome di interfaccia esterna di un oggetto (spesso chiamata anche con l’acronimo API di un oggetto).

A livello esterno quindi un oggetto non è altro che un dispositivo accessibile dall’esterno grazie alla sua interfaccia esterna. E’ da tenere presente che l’effettivo funzionamento di un oggetto, ovvero gli algoritmi che utilizza per rispondere ai metodi, non sono (ed è giusto che non siano) a conoscenza di un eventuale utilizzatore.

Come anticipato, i metodi caratterizzano cio che un oggetto sa fare, ma a questo punto potremmo essere più precisi definendo i metodi come le richieste a cui un oggetto sa rispondere. Alcuni linguaggi di programmazione ad oggetti (ad esempio ObjC) permettono di invocare su di un oggetto metodi qualunque e, ovviamente, l’oggetto reagirà solamente per i metodi per i quali era stato definito un comportamento.

Facciamo un esempio:

L'oggetto Orologio visto dall'esterno.

L’oggetto Orologio è rappresentato in figura. Noi non sappiamo nulla di come e quali dati contenga e gestisca l’oggetto Orologio. Come è rappresentata l’ora? Con tre interi (ore, minuti, secondi)? Con il numero di secondi dalla mezzanotte? Non lo sappiamo e non ci importa.

Quello che ci interessa è che se noi invochiamo su Orologio il metodo ottieniOra riceveremo l’ora esatta e invocanto impostaOra potremo modificare l’ora.

Uno dei vantaggi di questo approccio è che se un giorno il programmatore che gestisce l’oggetto Orologio volesse stravolgere l’oggetto Orologio, purchè non modifichi l’interfaccia esterna, noi utilizzatori non dovremo preoccuparci perché tutto continuerà a funzionare tranquillamente.

Ma non possiamo limitarci ad usare oggetti altrui, prima o poi, saremo costretti a creare i nostri oggetti. Diamo quindi uno sguardo all’interno di un oggetto.

Autopsia di un oggetto.

Entrare nella struttura interna di un oggetto è simile ad aprire il cofano di un auto. La differenza principale con la struttura esterna è la presenza degli attributi. Gli attributi rappresentano ciò che un oggetto sa di se. Vengono perciò gestiti dall’oggetto stesso: è buona norma infatti non permettere mai l’accesso diretto esterno agli attributi ma permettere la loro modifica/lettura solo attraverso i metodi di interfaccia.

Altra differenza importante è la presenza di metodi accessibili solo dall’oggetto stesso. Questi metodi consistono spesso in metodi ausiliari che non hanno rilevanza esplicita per l’esterno ma sono utilizzati solo dai metodi dell’oggetto stesso.

Un esempio di metodo interno potrebbe essere un algoritmo che converte dei valori di un attributo in un qualche formato che un altro metodo (probabilmente un metodo esterno) elaborerà e restituirà all’esterno.

Ovviamente nella realtà non ci troveremo spesso a vestire i panni di utilizzatore e di programmatore di un oggetto contemporaneamente. Quindi bisogna fare dimestichezza in tutte e due le “divise”.

Ora che conosciamo per bene cosa è un oggetto, andremo ad analizzare cosa rappresentare con un oggetto. Penso che alcuni di voi abbiano già intuito la cosa, ma ci sono due aspetti e alcune problematiche da approfondire: le differenze fra oggetti come entità e oggetti come valori.

GAPG – Bozza 01

THeK3nger — Mon, 17 Nov 2008 07:47:37 +0000

Come già ho annunciato sto convertendo, ampliando e correggendo i 10 articoli di Guida alla Programmazione Generale in pdf. L’università ha rallentato molto questo processo e quindi per mostrarvi la mia buonafede inizio a darvi il link per la prima bozza.

Per il momento contiene gli articoli da 1 a 6 con alcune imprecisioni corrette.

GAPG – Bozza01

Lisp – Come iniziare a scrivere in Lisp

THeK3nger — Wed, 12 Nov 2008 17:39:15 +0000

Vi verrà lo sturbo.

Nel corso di Modelli e Complessità che sto seguendo è stato introdotto il Lisp (List Processor o meglio Lots of Infuriating & Silly Parenthesis) come esempio di linguaggio funzionale.

Come ho accennato in passato la programmazione funzionale è un tipo di paradigma che pone l’accento sulla definizione di funzioni poichè il flusso del programma assume la forma di valutazione di funzioni matematiche e in particolare delle funzioni ricorsive.

Senza addentrarci troppo in tecnicismi di informatica teorica passiamo subito ad affrontare la “pratica” con il linguaggio Lisp.

E’ importante precisare però che il Lisp, sebbene funzionale, può benissimo essere usato come linguaggio imperativo. Tuttavia non affronteremo questo argomento in questo momento.

In questo tutorial useremo come shell di interprete GCL (GNU Common Lisp) e come editor Emacs (utilizzeremo Emacs non solo perchè è esso stesso scritto in Lisp ma perchè ci fornisce facilmente la colorazione della sintassi e altre cosine utili che altri editorn non forniscono).

Installare CGL.

Per prima cosa dobbiamo installare l’interprete. Di interpreti per il Lisp ed i relativi dialetti esistono una montagna di shell (ad esempio clisp, cmucl, e altri) ma noi useremo GCL perchè l’ho trovata la meno “incasinata” per molti comandi essenziali ed è conforme agli altri applicativi GNU.

Per installarla è veramente molto semplice. Basta digitare il classico

apt-get install gcl

e eventualmente

apt-get install gcl-doc

con privilegi di root (con sudo o su) per avere la nostra shell (e la sua documentazione) completamente funzionante avviabile con un semplice:

gcl

Installare EMACS.

Anche installare EMACS è qualcosa di semplicissimo, basta digitare:

apt-get install emacs emacs22-gtk

PS: Esistono centinaia di pacchetti ed estenzioni di emacs per fargli fare qualunque cosa, dal giocare a scacchi, ad usarlo come client per MSN e Jabber, ma ovviamente credo sia roba superflua per ora!

Scrivere il nostro primo file Lisp.

Potremmo utilizzare il Lisp anche direttamente dalla shell gcl ma, come forse noterete, è molto più comodo scrivere su un file tutto il codice e passarlo direttamente alla shell. In questo modo potremmo salvare il nostro programma, creare moduli da riutilizzare in seguito o semplicemente evitare di riscrivere ogni volta da capo funzioni complesse.

Per fare questo apriamo Emacs.

Ora io utilizzerò le scorciatoie da tastiera, sebbene gli stessi comandi si possono fare per via grafica, perché le trovo estremamente più veloci.

Aprite un file (esistente o non) premendo:

CTRL + x
CTRL + f

E digitando il nome del file e il relativo percorso (si può navigare facilmente con TAB).

Creiamo ad esempio il file primo_lisp.lisp.

Ora possiamo scrivere il programma che ci pare. Una volta finito salviamo premendo:

CTRL + x
CTRL + s

Adesso che il nostro file è salvato abbiamo due modi per eseguirlo:

Digitando da terminale gcl -f primo_lisp.lisp
O ancora meglio aprendo gcl da terminale e importando il file direttamente dalla shell con il comando (load “primo_lisp.lisp”)

Grazie a questo secondo metodo potremo fare prove sulle funzioni definite in “primo_lisp.lisp”. Ad esempio possiamo usare due ottime funzioni di debugging:

il comando (describe A) che stampa a schermo la descrizione dell’oggetto A (ovvero se è una funzione, un numero, una lista, ecc…
il comando (step A) che esegue le funzioni specificate in A passo per passo!! Veramente ottimo per il debug.

Non vi resta che provare a scrivere alcune funzioni e provare questi comandi per prendere confidenza!