Quarto di miglio » Programmazione

Ti 89 Titanium e compatibilità

Corrado — Fri, 05 Dec 2008 20:33:30 +0000

Ho acquistato da poco una TI89 Titanium. Per chi, come me, dovesse avere qualche problema a far funzionare i programmi scritti per la TI 89, segnalo la patch hw3patch scritta da Kevin Kofler. La patch permette di utilizzare programmi scritti per le altre versioni della TI89 con la Titanium, nonché di installare programmi scritti per vecchie versioni dell’OS.
Attenzione! La patch agisce sulla RAM della vostra calcolatrice disabilitando alcune protezioni del sistema, l’autore non offre alcuna garanzia sul corretto funzionamento della vostra calcolatrice.

Php-stat e tempi di permanenza sballati

Corrado — Tue, 04 Mar 2008 22:24:08 +0000

Da un po’ di tempo, su un paio di siti che gestisco, si è presentato un problema con la visualizzazione dei report delle statistiche riguardanti i tempi di permanenza medi sulle pagine registrati con php-stat. I tempi di permanenza medi, risultavano falsati da un dato evidentemente errato, che chissà come è stato registrato nel Db.

Chiunque riscontrasse lo stesso problema, può risolvere semplicemente in pochi minuti:

1) da php-stat controllate all’interno della sezione “Tempi di permanenza” quale pagina presenta il dato errato.
2) da phpmyadmin o dal vostro programma di amministrazione del Db preferito, eseguite una query sulla tabella php_stats_pages, sulla pagina con il problema
3) sostituite con un dato di massima, o eliminate il record che presenta il problema

Ajax: Sviluppare applicazioni Web 2.0

Corrado — Sun, 10 Feb 2008 20:40:21 +0000

Non sono mai stato un estimatore di Ajax, sopratutto per le difficoltà legate all’accessibilità dei contenuti gestiti tramite Javascript.
Purtroppo (o per fortuna?) i trend spingono in senso contrario e mi costringono ad approfondire, o per meglio dire ad imparare, questa tecnologia.

Mi ritrovo tra le mani una copia del libro “Sviluppare applicazioni web 2.0” di Christophe Porteneuve. In copertina si legge:

SCOPRIRE
la capacità di interazione e le possibilità comunicative del Web 2.0

IMPARARE
a usare AJAX per migliorare e velocizzare l’esperienza utente

Voglio cominciare un esperimento, sulla falsa riga di qualcosa che ho letto recentemente in un altro blog: il libro è composto da 9 capitoli. Un capitolo alla settimana per 9 settimane (Vacanze di Natale e Capodanno escluse, naturalmente!).
Al termine di ognuno scriverò un breve riassunto corredato da qualche esercizietto di esempio, perché mettere nero su bianco mi ha sempre aiutato a riordinare le idee, e perché non si sa mai che non possa tornare utile in futuro; a me, o a qualcun’altro.

RAD per wxPython

Corrado — Wed, 05 Dec 2007 22:54:34 +0000

Da un mesetto circa sto provando un po’ di tool per lo sviluppo di interfacce grafiche in Python. Cercando un’alternativa a Boa e WxGlade sono incappato in un progetto che, anche se in fase embrionale, mi è piaciuto: VisualWx.

A volte il look’n feel conta più di tutto il resto.

Qui il Wiki (in Italiano) del progetto.

Pile e parser RPN in Python

Corrado — Tue, 30 Oct 2007 20:31:47 +0000

La notazione polacca inversa (RPN) è una sintassi utilizzata per scrivere formule matematiche. Sostuisce all’uso delle parentesi e delle regole sulla precedenza degli operatori della notazione infissa una forma postfissa, ovvero che post pone agli operandi gli operatori. Ad es:

5 * 2 corrisponde a 5 2 *
(10 * 6) + 4 corrisponde a 10 6 * 4 + oppure 4 10 6 * +

Come piccolo esercizio per un esame ho scritto questo semplice parser RPN, che fa uso delle pile per sviluppare la formula matematica:

import re
 
class stack(list):
    def __init__(self):
        self.Elementi = []
 
    def push(self, Elemento, index = None):
        if(index == None):
            self.Elementi.append(Elemento)
        else:
            self.Elementi.insert(index, Elemento)
 
    def pop(self, index = 0):
        return self.Elementi.pop(index)
 
    def index(self, value):
        return self.Elementi.index(value)
 
    def count(self):
        indice = 0
        for element in self.Elementi:
            indice += 1
        return indice
 
    def EVuota(self):
        return (self.Elementi == [])
 
class ParserRPN():
    def __init__(self):
        self.Stack = stack()
 
    def analizza(self, espressione):
 
        #lista degli operatori
        ListaToken = re.findall("[^0-9s]", espressione)
 
        for element in espressione.split():
            try:
                self.Stack.push(float(element))
            except:
                self.Stack.push(element)
 
        for Token in ListaToken:
            #trovo la posizione dell'operatore nello stack
            TokenIndex = self.Stack.index(Token)
 
            #calcolo la posizione dei due operandi e rimuovo
            #l'operatore dallo stack
 
            a = self.Stack.pop(TokenIndex - 2)
            b = self.Stack.pop(TokenIndex - 2)
            self.Stack.pop(TokenIndex - 2)
 
            #eseguo l'operazione
            if(Token == "+"):
                Risultato = a + b
            elif(Token == "*"):
                Risultato = a * b
            elif(Token == "-"):
                Risultato = a - b
            elif(Token == "/"):
                Risultato = a / b
 
            self.Stack.push(float(Risultato), TokenIndex - 2)
        return self.Stack.pop()