Transizione

Eccoci giunti finalmente alla grande transizione. Finalmente, dopo tanto (forse troppo) tempo ci si separa dal nido. L'unica speranza è di non essere costretti a tornare indietro. E' un po' come il suicidio, non lo puoi sbagliare.

Font e GDLibrary

Oggi stavo cercando di scrivere del testo un un'immagine generata da php 5 usando le librerie GD. Sembrava uno cosa molto semplice, bastava usare la funzione imagetfttext() passandogli tra i vari parametri anche il nome del font da usare.
E invece no, ottenevo sempre dei simpatici quadratini: il font non veniva caricato. Dopo un bel po' di ricerche sul manuale di php e su google, ho scoperto che le versioni più recenti delle GD richiedono l'uso di font OpenType, che è un formato sviluppato da Microsoft e Adobe e a quanto pare abbastanza diffuso e con dei vantaggi rispetto agli altri tipi di font.
OSX di default non ha font OpenType, ma con un'altra ricerca ho trovato un font OpenType gratuito da scaricare, l'ho downloadato, l'ho copiato nella directory dello script, ho rilanciato lo script stesso e oplà, il testo è magicamente comparso sull'immagine.

Wardriving!

Connessi dalla macchina di Andrea, in via Barletta numero 76!

Esperimenti con Django, parte II

La mia prima miniapplicazione funziona: mostra l'elenco dei guestbook e l'elenco dei messaggi per ogni guestbook presente. Aggiungiamo ora l'inserimento di un nuovo messaggio.
Editiamo quindi il template messaggi.html, aggiungendovi al fondo un semplice form HTML:

[form method="post" action="ins/"]
[fieldset]
[label]Nome:[/label[input type="text" name="nome"][br /]
[label]Email:[/label][input type="text" name="mail"][br /]
[label]Messaggio:[/label][textarea name="msg"][/textarea][br /]
[input type="submit" value="Inserisci"]
[/fieldse][/form]
Notate l'action del form: punta a ins/.
Editiamo quindi il file urls.py, aggiungendo la riga

(r'^guestbook/(?P\d+)/ins/$', 'mysite.guestbook.views.insmessage')

alla variabile urlpatterns.
Ora dobbiamo solo creare la nuova view, dentro a views.py:

def insmessage(request, guestbook_id):
m = Messaggi()
m.autore = request.POST['nome']
m.email = request.POST['mail']
m.messaggio = request.POST['msg']
m.guestbook_id = guestbook_id
m.data = strftime("%Y-%m-%d %H:%M:%S")
m.save()
return HttpResponseRedirect('/guestbook/'+guestbook_id+'/')

Due parole: questa funzione crea un nuovo oggetto di tipo Messaggi (perchè ho chiamato la classe al plurale non me lo spiego), ne setta gli attributi con i dati che arrivano tramite post, attraverso il dictionary POST dell'oggetto HttpRequest, lo salva su db e fa un redirect alla pagina che mostra i messaggi.
Tutto molto semplice, ovviamente esiste anche un dictionary GET per dati in get.

Il sistema di django è molto bello, la separazione tra template, models e views è netta e molto chiara e effettivamente una volta che si prende la mano mi pare che possa essere un ottimo strumento per velocizzare lo sviluppo.

Modifiche layout

Andrea ha cambiato il template, io ho aggiunto alla barra laterale il feed dei bookmark miei e suoi su del.icio.us. Ci piace? Proviamo un po' e poi vediamo.

AT Commands

Non mi ricordo mai i comandi at per dialogare con un modem attraverso la seriale
Questa pagina ha un bell'elenco per i modem in generale.
Questa ne ha ancora di più ma sono meno chiari.

Questi sono quelli più utili da usare con Hyper Terminal di BigM.
Da notare che dove c'è n o k bisogna sostituire con un numero.

ATEn      Command Echo            (0=OFF,      1=ON  )
ATQn      Result Code Suppression (0=OFF,      1=ON  )
ATVn      Define Response Format  (0=NUMERIC,  1=TEXT)
AT+CMGF=n Message Format          (0=PDU,      1=TEXT)
AT+CSCA   Service Centre Address
AT+CMGL   List Messages
AT+CMGR=k Read Message            (k = message number)
AT+CMGD=k Delete Message          (k = message number)

fseek() in Java?

Usando java.io.DataInputStream non si può.

Si può invece con java.io.RandomAccessFile, che ha un bellissimo metodo seek() definito così:
void seek(long pos)
Sets the file-pointer offset, measured from the beginning of this file, at which the next read or write occurs.

Così dovrei riuscire a stampare i colori dei pixel di una file bitmap dall'angolo in alto a sinistra in giù senza caricare tutta l'immagine in memoria.

IMPORTANTISSIMO

questo post è un fake, solo per avere più tag java di tutti gli altri. anche se Dave domani mi srtozza.

Infinite Jest

Infinite Jest - David Foster Wallace
La figata più figosa che ciè. No davvero sto libro è una cosa, ma una cosa che neanche te lo immagini. Bè te lo immagini se qualcuno che ti conosce bene ti ha assicurato che ti piacerà, ma tant'è. E' un po' lunghetto, più di unocontrezeridietro, tanto per capirci, il che, dato lo splendore, è una feature. Le prime 2,3cento pagine sono tutte in salita, mica per scherzo, una fatica del diavolo, ma se ce la fai......ommioddio se ce la fai come te la spassi, e poi non finisce più. una meraviglia. Solo che poi ti viene un po' di tristezza a pensare che lo finirai perchè non sai se troverai mai una cosa così, multistratificata e multidimensionale. Ma tanto tutte le cose finiscono, questa un po' più lentamente del solito (con relativezza parlando); quindi meglio.

Esperimenti con Django

Dopo aver letto e copiato pari pari il tutorial di Django, ottenendo una simpatica applicazione web per gestire sondaggi, ho deciso di provare a fare qualcosa da solo.
Cercherò di sviluppare una webapp per gestire e visualizzare un guestbook.
Per prima cosa occore creare l'applicazione con il comando

python manage.py startapp guestbook

Questo comando genera una directory di nome guestbook, con dentro 3 file: __init__.py, models.py, views.py.
Ora bisogna creare le classi che comporranno l'applicazione. Per un semplice guestbook, bastano due classi: Guestbook e Messaggi. Creiamole editando il file models.py

from django.db import models

class Guestbook(models.Model):
  nome = models.CharField(maxlength=200)
  data_creazione = models.DateTimeField('data di creazione')

class Messaggi(models.Model):
  guestbook = models.ForeignKey(Guestbook)
  messaggio = models.TextField()
  autore = models.CharField(maxlength=50)
  data = models.DateTimeField('data messaggio')
  email = CharField(maxlength=50)

Ora dobbiamo dire a Django che il guetbook fa parte del progetto corrente, editando il file settigs.py e aggiungendo 'mysite.guestbook' a INSTALLED_APPS.
Ora Django può creare le tabelle su db che rappresentino gli oggetti appena definiti. Il comando python manage.py sql guestbook ci mostra le query che verrano lanciate per fare ciò:

BEGIN;
CREATE TABLE `guestbook_messaggi` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
    `guestbook_id` integer NOT NULL,
    `messaggio` longtext NOT NULL,
    `autore` varchar(50) NOT NULL,
    `data` datetime NOT NULL,
    `email` varchar(50) NOT NULL
);
CREATE TABLE `guestbook_guestbook` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
    `nome` varchar(200) NOT NULL,
    `data_creazione` datetime NOT NULL
);
ALTER TABLE `guestbook_messaggi` ADD CONSTRAINT guestbook_id_referencing_guestbook_guestbook_id FOREIGN KEY (`guestbook_id`) REFERENCES `guestbook_guestbook` (`id`);
COMMIT;

Per fargliele eseguire, si usa il comando python manage.py syncdb, che sicronizza il database con gli oggetti definiti.
Django aggiunge automaticamente un campo id autoincrementante come chiave primaria delle tabelle, e anche i campi che sono chiavi esterne, specificati nella definizione dell'oggetto con models.ForeignKey(tabellareferenziata).

Ora abbiamo tutto pronto per iniziare a sviluppare il guestbook, ma prima utilizziamo una delle caratteristiche più interessanti di Django, la creazione automatica del backoffice per gestire le nostre tabelle.
Se nel file settings.py, all'interno di INSTALLED_APPS, è presente l'applicazione django.contrib.admin, allora il backoffice è già attivo e funzionate, dobbiamo solo dire ai nostri oggetti che dovranno apparirvi.
Per fare ciò, dobbiamo creare una sottoclasse di Guestbook e di Messaggi, di nome Admin, editando il file models.py:

class Guestbook(models.Model):
    # i vari campi
    class Admin:
        pass
class Messaggi(models.Model):
    # i vari campi
    class Admin:
        pass

Salviamo, puntiamo il browser su http://www.miosito.com/admin/ e vedremo l'interfaccia del backoffice.
Per ogni oggetto, ci viene data la possibilità di crearne di nuovi, modificarli o di eliminarli.
E' possibile raffinare l'aspetto e la funzionalità di questo backoffice modificando le sottoclassi Admin degli oggetti, ma già la versione standard è completissima e perfettamente usabile.

Ora possiamo iniziare a creare le funzionalità del guestbook vero e proprio.
Per prima cosa, editiamo il file urls.py, in modo che somigli a qualcosa del genere:

urlpatterns = patterns(
    (r'^guestbook/$', 'mysite.polls.views.index'),
    (r'^guestbook/(?P\d+)/$', 'mysite.guestbook.views.showmessages'),
)

Django usa un sistema di espressioni regolari per associare gli url alle fuzionalità di un applicazione: nel nostro caso, quando viene chiamata un url del tipo http://www.miosito.com/guestbook, il server caricherà la view contenuta in mysite.polls.views.index. Cos'è una view? E' un tipo di pagina, che serve ad una specifica funzione e ha un suo template.
Le view si definiscono nel file views.py.
Per prima cosa, creiamo la view che verrà caricata come index:

from django.template import Context, loader
from mysite.guestbook.models import Guestbook
from django.http import HttpResponse

def index(request):
    gb = Guestbook.objects.all().order_by('-data_creazione')
    t = loader.get_template('guestbook/index.html')
    c = Context({
        'gb': gb
    })
    return HttpResponse(t.render(c))

La view index estrae tutti gli oggetti Guestbook dal db, in ordine discendente rispetto alla data di creazione, carica il template, crea un context, ovvero un dizionario che mappa nomi di variabili del template su nomi di oggetti, renderizza il template con il context e restituisce un oggetto HttpResponse.

Ora manca solo il template, creiamolo:

[html]
[body]
[center]Guestbook[/center]
{% if gb %}
[ul]
{% for g in gb %}
[li][a href="{{g.id}}"]{{g.nome}}[/a][/li]
[/ul]
{% endfor %}
{% else %}
[center]Nessun guestbook presente[/center]
{% endif %}
[/body]
[/html]

(Ho messo le quadre al posto di <> se non blogger schizza.)
Questo template riceve l'oggetto gb dalla view, e per ogni oggetto di tipo Guestbook dentro a gb stampa un link con il nome del guestbook.
Se ora apriamo http://www.miosito.com/guestbook, vedremo l'elenco dei guestbook.

Ora dobbiamo creare la view che visualizzi l'elenco dei messaggi di un certo guestbook:

def showmessages(request, guestbook_id):
    g = Guestbook.objects.get(pk=guestbook_id)
    m = Messaggi.objects.filter(guestbook=guestbook_id).order_by('-data')
    t = loader.get_template('guestbook/messaggi.html')
    c = Context({
      'm': m,
      'g': g           
     })
    return HttpResponse(t.render(c))

e il template messaggi.html:

[html]
[style]
h3 {
 font-size: 14px;
 font-family: verdana;
 font-weight: bold;
}
h1 {
 font-size: 16px;
 font-family: verdana;
 font-weight: bold;
}
p  {
 font-size: 10px;
 font-family: verdana;
 font-weight: normal;
 border: 1px solid;
 width: 200px;
}
[/style]
[body]
[center]
[h1]{{ g.nome }}[/h1]
[br]
{% for mex in m %}
 [div]
 [h3]{{mex.autore}} {{mex.data}} {{mex.email}}[/h3]
 [p]{{mex.messaggio}}[/p]
 [/div]
{% endfor %}
[/center]
[/body]
[/html]

Ecco fatto.
Ora puntiamo il browser su http://www.miosito.com/guestbook/1/ e vedremo l'elenco dei messaggi inseriti nel nostro primo guestbook!

Prossimamente, aggiungerò un form per inserire nuovi messaggi, per imparare a gestire il passaggio di dati in POST.

Log4j

Lo so che tutti conoscono log4j e che tutti lo usano e non si accorgono neanche di farlo, però io ho iniziato solo ora a usarlo e sono felice...
Quindi la prima cosa da fare è scaricarlo da qui. E' un progetto ospitato da apache e questo dovrebbe bastare per dissipare qualsivoglia dubbio (ahah come parlo bene).
Seconda cosa aggiungerlo al classpath della propria applicazione (sto parlando di java nel caso non fosse chiaro); quindi un bell'

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;

poi nella dichiarazione delle variabili di classe

static Logger logger = Logger.getLogger(MyClass.class);

MyClass è il nome della classe su cui stai lavorando.A questo punto se l'applicazione ha un main ci puoi dovresti mettere un

PropertyConfigurator.configure("log4j.properties");

che dice al logger dove recuperare le info di configurazione, infatti non vogliamo dover ricompilare tutte le volte che decidiamo di modificare delle impostazioni per il logger.
Il file log4j.properties sarà una cosa così

# Set root logger level to DEBUG and its only appender to A1.
log4j.rootLogger=INFO, A1
#log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1=org.apache.log4j.RollingFileAppender
log4j.appender.A1.File=theLog.log
log4j.appender.A1.MaxFileSize=1024KB
# A1 uses PatternLayout.
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r [%d] %-5p %c - %m%n

Non ciò voglia di spiegare cosa significa perciò copiare e incollare e tener presente che è una configurazione piuttosto agricola.

E' fatta, il logger è pronto a questo punto tutte le volte che si vuole loggare qualcosa nella classe è sufficiente scrivere

logger.info("o che bello");

o

logger.warn("Brrrrr");

o

logger.debug("noiosezze");

o

logger.error("ahiahahia");

o

logger.fatal("AAAAAAAAAHHHHHHHHHHHHHHH");

o farsi dei logger personalizzati tipo

logger.porcaPutt("Questo non dovrebbe mai accadere");

ma per i logger personalizzati RTFM.

Ultima nota. Se si sta sviluppando una classe senza main è sufficente

import org.apache.log4j.Logger;

e

static Logger logger = Logger.getLogger(MyClass.class);

con i vari

logger.info() logger.warn()

etc..

Da signed ad unsigned

Come si fa a convertire un numero da signed ad unsigned?
Il problema è venuto fuori cercando di leggere in Java un file bmp, formato che salva le informazioni dei colori dei pixel in tre byte per pixel, uno per componente RGB. I valori sono ovviamente solo interi positivi su 8 bit, ma leggendoli Java li interpreta come interi con segno a 7 bit, ovvero come numeri codificati in complemento a due su 8 bit.
Come si fa la conversione?
Così:

private static int unsignedByteToInt(byte b) {
 return (int) b & 0xFF;
}

Il metodo legge un byte, lo mette in AND con il valore esadecimale FF e restituisce il risultato castato a int.
Gli int di Java sono su 4 byte, l'AND lascia inalterati gli otto bit della variabile b e mette a zero i 24 bit in più. In questo modo il bit del segno (quello più significativo) è zero e il numero viene interpretato come positivo.
E vualà, ecco il valore che cerchiamo.

Installare Django su OSX

Fomentato dalla lettura di alcuni post su forum vari e dal tutorial sul sito, ho deciso di installare Django. Django è un framework scritto in python che, stando a quello che dice il sito, dovrebbe semplificare moltissimo la creazione di applicazioni web, specialmente gestionali, cms e applicazioni database-driven. Il tutorial, anche se purtroppo è incompleto al momento, fa vedere delle bellissime cose, e allora mi sono deciso a dargli un'occhiata.

L'installazione non è stata liscissima: dopo aver scaricato il tar.gz contenente Django, ho lanciato lo script di install, che ha funzionato al primo colpo. Al momento però di provare a fare delle operazioni che richiedevano accesso a mysql, ho scoperto che la distribuzione di python che c'è su OSX non ha le librerie necessarie. Allora le ho scaricate, da qui. Al momento di installarle, mi hanno richiesto setuptools versione0.6c5 o superiori (a quanto ho capito, setuptools è un sistema per python che semplifica le installazioni dei pacchetti aggiuntivi, una specie di synaptic o giù di lì). Ho scaricato anche questo, da qui, e alla fine sono riuscito a far andare il tutto.

Ora django può accedere al db, e molto presto mi dedicherò alle sue API, che sembrano molto interessanti.

E per la gioia di Andrea, ho pure trovato un plugin di Eclipse per Python, PyDev.

Out of Bound

Oggi, mentre tentavamo di studiare CPS, ad Andrea e me è venuta l'idea di aprire un blog per raccogliere frammenti di codice, programmi fatti da noi, how-to, link utili e/o interessanti e cose di questo genere.
Detto fatto, ecco il blog. Chissà se avremo la voglia e la costanza di portarlo avanti. O anche solo la voglia di customizzarlo a dovere.

E Andrea mi ha già chiamato perchè non riusciva ad accettare l'invito a diventare coautore. Iniziamo bene.