frafra.eu

Per capire dove nasce questa idea, vi consiglio di leggere la prima e la seconda puntata

Giusto questa sera, sono riuscito a fare il porting su Symbian della mia piccola applicazione C++/QT. Ecco come fare:

Requisiti: dovete avere gcc/g++ installato, make, qmake, le librerie di sviluppo di libssl e zlib, wine, e un po’ di pazienza

In una cartella, scaricate:

• L’SDK per Symbian “5th Edition”
• Le QT per Symbian (4.6.3)
• Il file s60_open_c_cpp_plug_in_v1_6_en.zip
• Il file gnu-csl-arm-2005Q1C-arm-none-symbianelf-i686-pc-linux-gnu.tar.bz2
• Il file gnupoc-package-1.15.tar.gz
• Lo script gnupoc_1.15_installer_v2.sh
• Lo script qt_for_symbian_4.6.3_all_in_one_linux_installer_v3.sh
• QT Mobility (1.0.2 – opzionale)

A questo punto bisogna creare (in una posizione a piacimento della nostra home directory), la cartella “gnupoc”, contenente la cartella “qt”, che a sua volta deve contenere la cartella “bin”. Una volta creata questa struttura, bisogna avviare il primo script scaricato, in questo modo:

$ bash gnupoc_1.15_installer_v2.sh `pwd` $GNUPOC 5.0

“$GNUPOC” deve essere sostituito col percorso assoluto della cartella poco fa creata, senza slash (“/”) finale.  Se tutto è andato bene, vi dirà di dare un paio di comandi da terminale per impostare l’ambiente, ovvero:

export PATH=$GNUPOC/bin:$PATH
export EPOCROOT=$GNUPOC/symbian-sdks/5.0/

A questo punto aggiungiamo a $PATH anche il posto dove verranno installate le nuove QT, e avviamo il secondo script:

export PATH=$GNUPOC/qt/bin:$PATH
bash qt_for_symbian_4.6.3_all_in_one_linux_installer_v1.sh `pwd` $GNUPOC/qt

Se tutto è andato bene, ci verrà mostrato un messaggio analogo al precedente. Noi eseguiremo, per sicurezza, il secondo comando consigliato dallo script, ovvero:

unset QMAKESPEC

Voilà! Adesso basta andare in un nostro progetto (ricordatevi di dare sempre i comandi “export” visti qui sopra, altrimenti non compilerete per Symbian), e digitare:

qmake
make debug-gcce
make sis

Vi ritroverete un file con estensione “.sis” pronto per essere installato sul vostro smartphone. Ovviamente su quest ultimo, dovrete installare anche le dipendenze. Queste (assieme a qualche programma di prova) sono presenti in “$GNUPOC/qt/”. Per installare le QT sul vostro cellulare, basta installare il file “qt_installer.sis”.

Ora, un paio di dritte:

• Nel vosto file progetto “.pro”, potrebbe essere utile creare una sezione dedicata alla compilazione su Symbian. Nel mio caso, volevo permettere alla mia applicazione di accedere ad internet, e quindi ho aggiunto la seguente linea:

  symbian:TARGET.CAPABILITY = NetworkServices

• Nei vostri file sorgente, potrebbe essere utile inserire una struttura di questo tipo:

  #ifdef Q_OS_SYMBIAN
  /* codice per Symbian */
  #else
  /* codice per le altre piattaforme */
  #endif

  Ovviamente “#else” è opzionale.

• Tenete conto che i cellulari hanno un monitor molto piccolo. Nel mio programma ho preferito quindi mostrare meno informazioni e lanciare il programma a schermo intero, con le seguenti istruzioni:

  #ifdef Q_OS_SYMBIAN
      window.showFullScreen();
  #else
      window.show();
  #endif

  Il fatto scomodo è che la chiusura, se non è presente un bottone o una voce dedicata nel menù, dovrà essere effettuata dalla barra di Symbian che mostra le applicazioni attive (tasto menù tenuto premuto per qualche attimo, selezionare l’applicazione, premere il tasto “c”).

Per il resto che dirvi… Divertitevi! Vorrei ringraziare brunoabinader.blogspot.com, dal quale ho preso spunto per questa guida

Il pacchetto contenente il mio programmino modificato per funzionare anche su Symbian è lo stesso della volta scorsa (ho aggiornato l’archivio): kiva.tar.gz.

frafra C/C++, Guide, QT, Symbian C, Kiva, Linux, QT, Symbian

Aggiornamento: ho fatto il porting su Symbian! (vedi post seguente)

Nel precedente articolo ho mostrato un programma scritto in Python, che aveva la peculiarità di sfruttare esclusivamente le funzioni fornite da PyQT, facilitando così un porting verso C++/QT in futuro. Beh,  ho incominciato a riscrivere il programma ieri sera (grazie anche all’aiuto di Rief) e l’ho finito nel primo pomeriggio di oggi, con ottimi risultati (ovvero: non ci sono regressioni). Il codice non è molto bello (ve l’ho detto, non sono un bravo programmatore C++), e alcune cose le avrei potute gestire meglio, ma vi ricordo che il mio intento fondamentale era semplicemente trascrivere il programma in un altro linguaggio, non stravolgendone la forma e lasciando invariate le funzioni e l’aspetto.

Non vi mostro il codice qui perché è lunghetto, e perché è spezzato su più files, quindi vi allego tutto in un kiva.tar.gz. Il file gui.ui che trovate nel pacchetto è lo stesso che è stato utilizzato sia per generare gui.h per l’applicativo in C++, sia per generare gui.py (allegato al post di ieri) per la versione pythonica.

Il prossimo passo è, ovviamente, il porting su Symbian

frafra C/C++, QT, Symbian C, json, QNetworkRequest, QScriptEngine, QT

Aggiornamento: alla fine ho riscritto il programma in C++ (vedi post seguente)

Questo programma si interfaccia con le API di Kiva (una piattaforma online per finanziare i progetti di microcredito) e, dato un utente, visualizza i prestiti da lui finanziati. La particolarità sta nel fatto che non usa alcuna libreria propria di Python (ad esclusione di sys), ma esclusivamente PyQt4 (nello specifico: QtCore, QtGui, QtNetwork, QtScript). In parole povere, troverete che:

1. Non è stato usato urllib per prendere i dati dal web, ma QNetworkRequest, in modo tale che l’interfaccia grafica non si blocchi durante le operazioni di caricamento.
2. Non è stato utilizzato il parser json dell’anonima libreria di Python, ma è stato analizzato il codice grazie a QScriptEngine. L’unico vantaggio ha riguardato la gestione degli errori.

Perché ho voluto “farmi del male”? Semplice: dato che PySide non supporta ancora Symbian, ho deciso di scrivere il codice in Python nelle modalità appena mostrate, per poi riscriverlo in C++ e fare un bel pacchettino .sis da installare sul telefono Avrei potuto farlo direttamente in C++, ma dato che sono “arrugginito” non volevo mettere troppa carne al fuoco

Qui sotto metterò il cuore del programma, mentre mi limiterò ad allegare il file gui.py relativo all’interfaccia.

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
from gui import Ui_MainWindow
from PyQt4 import QtCore, QtGui, QtNetwork, QtScript
 
class Kiva(QtGui.QMainWindow):
    def __init__(self, parent=None):
        QtGui.QWidget.__init__(self, parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.network = QtNetwork.QNetworkAccessManager()
        self.engine = QtScript.QScriptEngine()
        self.name = ""
        QtCore.QObject.connect(self.network,
            QtCore.SIGNAL("finished(QNetworkReply*)"), self.load);
        QtCore.QObject.connect(self.ui.pushButton,
            QtCore.SIGNAL("clicked()"), self.refresh)
    def add(self, name, status, progress):
        row = self.ui.tableWidget.rowCount()
        self.ui.tableWidget.insertRow(row)
        qstatus = QtGui.QTableWidgetItem(status)
        self.ui.tableWidget.setItem(row, 0, qstatus)
        progressBar = QtGui.QProgressBar()
        progressBar.setValue(progress)
        self.ui.tableWidget.setCellWidget(row, 1, progressBar)
        qname = QtGui.QTableWidgetItem(name)
        self.ui.tableWidget.setItem(row, 2, qname)
    def get(self, req, **attrs):
        url = QtCore.QUrl("http://api.kivaws.org/v1%s.json" % req)
        for key, value in attrs.items():
            url.addQueryItem(key, str(value))
        self.network.get(QtNetwork.QNetworkRequest(url))
    def load(self, data):
        sc = self.engine.evaluate("(%s)" % QtCore.QString(data.readAll()))
        current = int(sc.property("paging").property("page").toInteger())
        total = int(sc.property("paging").property("pages").toInteger())
        if sc.property("loans").isArray():
            cursor = QtScript.QScriptValueIterator(sc.property("loans"))
            if current == 1:
                self.ui.tableWidget.clearContents()
                self.ui.tableWidget.setRowCount(0)
            cursor.next()
            while cursor.hasNext():
                tmp = {}
                for attr in ["status", "name"]:
                    tmp[attr] = cursor.value().property(attr).toString()
                for attr in ["funded_amount", "loan_amount", "paid_amount"]:
                    tmp[attr] = cursor.value().property(attr).toInteger()
                cursor.next()
                self.parse(tmp)
            if current == total:
                text = "%d loan(s) loaded" % self.ui.tableWidget.rowCount()
                self.ui.statusbar.showMessage(text)
                self.ui.pushButton.setEnabled(True)
            else:
                text = "Page %d of %d loaded" % (current, total)
                self.ui.statusbar.showMessage(text)
                self.get("/lenders/%s/loans" % self.name, page = current+1)
        else:
            self.ui.statusbar.showMessage("User %s not found" % self.name)
            self.ui.pushButton.setEnabled(True)
    def parse(self, loan):
        status = loan["status"]
        if status in ["fundraising"]:
            progress = 100*loan["funded_amount"]/loan["loan_amount"]
        elif status in ["in_repayment", "paid"]:
            progress = 100*loan["paid_amount"]/loan["loan_amount"]
        elif status == "defaulted":
            progress = 0 # TODO: Is there a way to know paid_amount?
        elif status == "refunded":
            return # FIXME: what is that status?
        self.add(loan["name"], status.replace("_", " "), progress)
    def refresh(self):
        self.ui.pushButton.setEnabled(False)
        self.name = self.ui.lineEdit.text()
        self.ui.statusbar.showMessage("Connecting...")
        self.get("/lenders/%s/loans" % self.name)
 
if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    kiva = Kiva()
    kiva.show()
    sys.exit(app.exec_())

frafra Python, QT json, Kiva, Python, QNetworkRequest, QScriptEngine, QT

VP8, il codec sviluppato da On2 Technologies, comprata mesi fa, è stato reso libero da royalities! Su Youtube i filmati che lo usano si stanno moltiplicando ogni attimo che passa, e i browser Chrome/Chromium, Firefox e Opera sono già stati rilascati in versione di testing col supporto a questo formato! Inoltre è stato lanciato webmproject.org, sito che vuole essere un punto di riferimento per siluppatori e utenti per tutto quelo che riguarda VP8.

Ecco dove trovare le ultime builds che lo supportano:

• Firefox (serie 3.7): nightly.mozilla.org/webm/
• Opera (serie 10.54): labs.opera.com/news/2010/05/19/
• Chrome (trunk): build.chromium.org/buildbot/snapshots

Per utilizzarlo in Youtube, bisogna abilitare la modalità HTML5 da: www.youtube.com/html5 Inoltre quando si fa una ricerca, bisogna aggiungere “&webm=1″ all’URL della pagina che si sta visitando. Questo risulterà inutile quando tutti i video saranno codificati nel nuovo formato. I nuovi file video saranno così composti:

• Conteninore: Matroska
• Audio: Vorbis
• Video: Vp8

Ah, sono già arrivatele prime critiche x264dev.multimedia.cx/?p=377 Comunque sia, oggi è un giorno da segnare sul calendario se si è amanti del web libero

frafra Guide html5, vp8, youtube

La mia webcam (ID 04f2:b036 Chicony Electronics Co., Ltd [uvcvideo]), funziona bene, ma ha un piccolo problema: si vede sottosopra Nello specifico il mio portatile è un Asus UL30A, ma immagino che la fix che ho trovato possa andare su tutti gli Asus della serie UL.
Così, dopo avere cercato un po’ su internet, ho segnalato il tutto a hdegoede (at) redhat.com, allegando alla mail i files creati coi seguenti comandi (come root):

lsusb > lsusb.log
dmidecode > dmi.log

Questo sviluppatore tiene una tabella delle webcam che soffrono di questo problema: proprio per questo motivo, ha bisogno di sapere quali modelli hanno bisogno di raddrizzare l’immagine.
Mi ha risposto il giorno successivo, con questa mail, dove spiega come compilare la versione di test di v4l-utils, come installarla, e come utilizzarla

Link: https://lists.berlios.de/pipermail/linux-uvc-devel/2009-June/004886.html

frafra Guide v4l, webcam

Chiedilo a pep8.py

Per chi non lo sapesse, la PEP 8 è una specifica di Python che indica come si dovrebbe scrivere il codice (definisce come deve essere l’indentazione ecc.).
Questo programma verifica se il codice scritto è conforme alla PEP 8

Link: http://github.com/jcrocholl/pep8/raw/master/pep8.py

frafra Python PEP 8, Python

Vi è mai capitato di dover (o voler) scaricare l’ultima versione di uno o più programmi? O sapere semplicemente se è stato rilasciato un aggiornamento?
Bene, a Frafra queste cose capitano, soprattutto quando si parla di sorgenti, compilazione, e compagnia cantante

Ho creato un programma Python (>= 3.x, testato su 3.1.1), che risolve automaticamente questo problema, con l’uso di un parser e di un crawler Sono cento linee giuste giuste, parzialmente commentate, con tanto di licenza (questa volta metto il file per intero, perché in primo luogo ho raggiunto un numero di linee tondo tondo, e in secondo luogo perché la prima linea è molto importante).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# takeit.py
#
# Copyright 2009 Francesco Frassinelli <fraph24@gmail.com>
#
#     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, either version 3 of the License, or
#     (at your option) any later version.
#    
#     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 <http://www.gnu.org/licenses/>.
 
""" This program shows you the latest version of a source package """
 
### HTMLParser patched version, see: http://bugs.python.org/issue755660
# $ cp /usr/local/lib/python3.1/html/parser.py HTMLParser.py
# $ wget http://bugs.python.org/file13041/htmlparser_error.diff
# $ patch -p0 HTMLParser.py < htmlparser_error.diff
import HTMLParser
import re, sys, urllib.request
 
servers = {
    "gnu":"http://ftp.gnu.org/gnu/",
    "linux":"http://ftp.kernel.org/pub/linux/",
    "vim":"http://ftp.vim.org/pub/vim/unix/",
} # List of available servers: add yours and report test them
 
class Parser(HTMLParser.HTMLParser):
    def __init__(self, page, callback):
        super(Parser, self).__init__()
        self.callback = callback
        self.page = page # Current page
    def handle_starttag(self, tag, attrs):
        if tag == "a":
            attrs = dict(attrs)
            if "href" in attrs:
                self.callback(self.page, attrs["href"])
    def error(self, message):
        pass # Overwriting default function, in order to skip any error
 
class Crawler:
    def __init__(self):
        self.source = re.compile(r"""^
            (.+?)-                  # package name
            ([\d\.-]+)              # version
            \.(tar\.bz2|tar\.gz)    # compression
            $""", re.VERBOSE) # VERBOSE is for multiline commented regex
        self.packages = dict()
    def inspect(self, page):
        print("I'm in:", page) # If there're errors, report it *always*
        with urllib.request.urlopen(page) as data:
            parser = Parser(page, self.callback)
            parser.feed(data.read().decode("utf_8", "ignore"))
            parser.close()
    def item(self, page, link):
        if self.source.match(link):
            res = self.source.search(link)
            package, version, compression = res.groups()
            if package == "0": # Should we use re.match("^\d+$", package)?
                return # Not properly detected: regex could be wrong
            if package not in self.packages:
                self.packages[package] = list()
            self.packages[package].append((version, page + link))
    def callback(self, page, link):
        # Special link / Backwards link / External link or absolute path
        useless = "?" in link or ".." in link or link.count("/") > 1
        if not useless:
            if link.endswith("/"):
                self.inspect(page + link) # Directory: recursive function
            else:
                self.item(page, link) # File: analize its name
    def results(self):
        for package, version in sorted(self.packages.items()):
            version, url = sorted(version, reverse = True)[0]
            yield package, version, url # Just to iterate it
 
def mycrawler(base, directory = ""):
    crawler = Crawler()
    crawler.inspect(base + directory)
    for package, version, url in crawler.results():
        print() # Newline ("\n")
        print("Name:", package)
        print(" -> Version:", version)
        print(" -> URL:", url)
 
if __name__ == "__main__":
    args = len(sys.argv)
    base      = (servers[sys.argv[1]],) if args > 1 else servers.values()
    directory = set(sys.argv[2:])       if args > 2 else ("",)
    for server in base:
        for page in directory:
            mycrawler(server, page)

frafra Linux, Python parser, Python, sorgenti

Vi ricordate il post sul gioco della vita di Conway (life)? Avevo scritto un algoritmo che oltre a implementare questo giochino (vedi Gioco della vita di Conway), ricercasse, con un bruteforce, tutte le figure che si ripetevano. Ora l’ho riscritto in C, supportando come parametri anche shift e step (sono un metodo grezzo per permettere un balance tra cpu/pc lanciando processi con parametri diversi) e un metodo economico (ma stupido) per il calcolo delle figure successive (vedere la variabile dirty e la nota n. 1). Quest’ultima caratteristica rende l’algoritmo intrinsecamente più veloce rispetto a quello che avevo scritto in Python, per cui le prestazioni sono sfasate (penso che questo trucco possa rendere il codice cinque volte più veloce mediamente, ma devo ancora studiare meglio gli effetti).

Tenendo conto di questo, il rapporto tra il programma in C, il programma Python convertito in C++ con Shedskin, la versione che usa Psyco, e la versione “classica”, è: (approssimativamente) 1:10:70:300. Ripeto: devo ancora applicare l’algoritmo nuovo in Python, e pare che gli ultimi tre dati si possano dividere per cinque circa, portando la versione Shedskin nello stesso ordine di grandezza della versione in C (questo sottolinea la validità del progetto), mentre la versione Pythonica sarebbe meno di due ordini di grandezza più lenta.

Il codice è questo Non lo commenterò passo passo, in quanto mi pare molto leggibile e simile a quello della versione in Python. Oltretutto, è già lungo di suo, quindi eviterei di riprendere inutilmente pezzi di codice per commentare la loro funzione Ho tolto la licenza… Tenete conto che, ovviamente, è sotto GPLv3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

#include <stdio.h>
#include <stdlib.h>
 
void clean(int *p, int dim) {
    int c; for (c=0; c<=dim; c++, p++) *p = 0;
}
 
void clone(int *from, int *to, int dim) {
    int c; for (c=0; c<=dim; c++) to[c] = from[c];
}
 
int compare(int *from, int *to, int dim) {
    int c;
    for (c=0; c<=dim; c++) { if (*to != *from) return 0; from++; to++; }
    return 1;
}
 
int main(int argc, char *argv[]) {
    if ((argc != 3) && (argc != 5)) {
        printf("Usage: %s [rows] [columns] [shift] [step]\n", argv[0]);
        return 1;
    }
    const int rows = atoi(argv[1]);
    const int columns = atoi(argv[2]);
    const int dim = rows*columns;
 
    int shift = 0;
    int step = 1;
    if (argc == 5) {
        shift = atoi(argv[3]);
        step = atoi(argv[4]);
    }
    if (shift >= step) {
        printf("shift/step are invalid.\n");
        return 2;
    }
 
    int clean_stage[dim];  int *clean_p = &clean_stage[0];
    clean(clean_p, dim);
 
    int alpha_stage[dim];  int *alpha_p = &alpha_stage[0];
    clean(alpha_p, dim);
    int beta_stage[dim];   int *beta_p = &beta_stage[0]; 
    clean(beta_p, dim);
    int first_stage[dim];  int *first_p = &first_stage[0];
    clean(first_p, dim);
 
    int i;
 
    int dirty;
 
    int p = dim-1;
    int r, sum, row, column, row_p, row_n;
    r = 0;
    while (1) {
        p = dim-1;
        while (first_stage[p] == 1) p--;
        first_stage[p] = 1;
        for (p++; p<dim; p++) first_stage[p] = 0;
        if (r%step != shift) {
            r++;
            continue;
        } else r = 0;
        clone(first_p, alpha_p, dim);
        dirty = 0;
        while (dirty != 18) { /* [1] Nota a fine programma... */
            for (i=0; i<dim; i++) {
                row = i/columns;
                column = i%columns;
                if (row == 0) {
                    row_n = i+columns;
                    if (column == 0) sum =\
                        alpha_stage[i+1] +\
                        alpha_stage[row_n] +\
                        alpha_stage[row_n+1];
                    else if (column < columns-1) sum =\
                        alpha_stage[i-1] +\
                        alpha_stage[i+1] +\
                        alpha_stage[row_n-1] +\
                        alpha_stage[row_n] +\
                        alpha_stage[row_n+1];
                    else sum = \
                        alpha_stage[i-1] +\
                        alpha_stage[row_n-1] +\
                        alpha_stage[row_n];
                } else if (row < rows-1) {
                    row_p = i-columns;
                    row_n = i+columns;
                    if (column == 0) sum =\
                        alpha_stage[row_p] +\
                        alpha_stage[row_p+1] +\
                        alpha_stage[i+1] +\
                        alpha_stage[row_n] +\
                        alpha_stage[row_n+1];
                    else if (column < columns-1) sum =\
                        alpha_stage[row_p-1] +\
                        alpha_stage[row_p] +\
                        alpha_stage[row_p+1] +\
                        alpha_stage[i-1] +\
                        alpha_stage[i+1] +\
                        alpha_stage[row_n-1] +\
                        alpha_stage[row_n] +\
                        alpha_stage[row_n+1];
                    else sum =\
                        alpha_stage[row_p-1] +\
                        alpha_stage[row_p] +\
                        alpha_stage[i-1] +\
                        alpha_stage[row_n-1] +\
                        alpha_stage[row_n];
                } else {
                    row_p = i-columns;
                    if (column == 0) sum =\
                        alpha_stage[row_p] +\
                        alpha_stage[row_p+1] +\
                        alpha_stage[i+1];
                    else if (column < columns-1) sum =\
                        alpha_stage[row_p-1] +\
                        alpha_stage[row_p] +\
                        alpha_stage[row_p+1] +\
                        alpha_stage[i-1] +\
                        alpha_stage[i+1];
                    else sum =\
                        alpha_stage[row_p-1] +\
                        alpha_stage[row_p] +\
                        alpha_stage[i-1];
                }
 
                beta_stage[i] = 0;
                switch (sum) {
                    case 2: beta_stage[i] = alpha_stage[i]; break;
                    case 3: beta_stage[i] = 1;
                }
            }
            if (compare(beta_p, first_p, dim)) {
                for (i=0; i<dim-1; i++) printf("%d ", first_stage[i]);
                printf("%d\n", first_stage[dim-1]);
                break;
            }
            if (compare(alpha_p, beta_p, dim)) break;
            clone(beta_p, alpha_p, dim);
 
            dirty++;
        }
    if (compare(first_p, clean_p, dim)) break;
    }
    return 0;
}
 
/* Nota [1]:
  Per non comparare sempre lo stage corrente con quelli precedenti,
  ho creato una modalità "stupida" di computazione. Il valore 18
  indica che non è necessario calcolare ulteriori stages se non si è
  ancora usciti dal ciclo, in quanto pare che non ci siano figure nel
  primo stadio, che si ripetano dopo il 18esimo stadio. */

P.S. Ho trovato una implementazione di questo giochino, molto carina, (senza bruteforce ovviamente) nella directory di Python 3.1.1 (ma penso si trovi anche in versioni precedenti) che usa curses, sotto Python-3.1.1/Demo/curses/life.py

frafra C/C++, Python C, Conway, game of life

E’ da un po’ di mesi che provo questa distribuzione poco nota. Le peculiarità?

1. In un cdrom sono contenuti tutti i programmi che ci si aspetterebbe, inclusi Openoffice, Gimp e Inkscape
2. Software aggiornatissimo
3. Veloce e leggera, ma non gli manca nulla (avvia anche cups e openssh al boot)
4. Gnome-centrica
5. Comodissima per compilare: il sistema di gestione dei pacchetti permette di scegliere se installare il binario o il sorgente, che verrà automaticamente compilato. Inoltre, è già inclusa una suite di programmi atti alla compilazione e allo sviluppo, oltre agli headers file di tutti i programmi (non c’è la divisione tra pacchetti -dev e non)

Pochi giorni fa, è stata rilasciata la versione 1.20. Non è stata ancora annunciata sul sito, ma è possibile scaricarla sotto la pagina di download.

Ho testato questa versione sul mio nuovo portatile (Asus UL30), e sono rimasto piacevolmente colpito Inoltre ho scritto un post sul forum di paldo dove mostro i problemi riscontrati, cosa si può migliorare, e un paio di workaround (utili quelli per utilizzare qemu in accoppiata con kvm e quello per creare una pennetta usb con paldo live, processo riutilizzabile per altre distribuzioni).

Il link è: Paldo forum – Topic 673

Il sito della distribuzione è: Paldo.org

frafra Guide, News

Il guardiano del router e compagna

Proprio ieri sono stato privato della mia linea ADSL casalinga (sto traslocando). In un primo momento, sono stato preso dal panico, pensando a un malfunzionamento del router (basato su Linux, ha sempre funzionato benissimo). Nonostante nella mia testa iniziasse a girovagare l’idea che mi avessero staccato la linea, per i primi 30 minuti il mio cervello non accettava il fatto, come quando viene a mancare un animale domestico al quale si è affezionati e nonostante ciò gli si riempie la ciotola di pappa Dopo qualche reboot dei miei tre scatolotti necessari per far funzionare la mia rete (un modem ethernet, un router 4 porte wifi, e uno switch 8 porte), ho guardato il “guardiano del router” (un piccolo pinguino di peluche che tiene lontani gli spiriti cattivi dalla mia connessione), e gli ho detto: “mi dispiace, per un po’ ti toccherà fare il disoccupato…”.

Detto ciò, ho passato un po’ di tempo a sistemare i miei programmini Python, e a pubblicare su github un po’ di codice (vedasi github.com/frafra, dove ho pubblicato anche una interessante applicazione PyQT4+Twisted per la chat), utilizzando il pc di un amico Questo mio amico (nonché vicino di casa), ha acconsentito a condividere temporaneamente la sua connessione wifi. E qui inizia il divertimento

Obiettivo: dare internet alla lan, utilizzando una rete wifi

Sostanzialmente, abbiamo bisogno di un pc che da una parte si connetta dalla rete wireless, e dall’altra condivida la propria connessione. Per fare ciò sul pc dotato sia di scheda wireless sia di scheda ethernet dobbiamo:

1. Connetterci alla rete (soluzione più semplice: networkmanager)
2. ifconfig eth0 192.168.100.1 up
   (ho scelto 192.168.100.1 perché così sono sicuro che non si tratti di una rete già in uso)
3. echo 1 > /proc/sys/net/ipv4/ip_forward
4. iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE
   (dove eth0 è l’inferfaccia di rete e wlan0 quella wifi)
5. Installare dnsmasq
6. Editare /etc/dnsmasq.conf, mettendo:
   domain-needed
bogus-priv
interface=eth0
dhcp-range=192.168.100.2,192.168.100.100,12h
7. Avviare il demone dnsmasq
   (spesso basta dare /etc/init.d/dnsmasq start o /etc/rc.d/dnsmasq start)

Tutti questi comandi devono essere avviati come superutente (quindi o aggiungendo sudo davanti a ogni comando, o digitando su [invio] prima di iniziare la procedura). Dagli altri computer ora potete connettervi come se fosse presente un normale router nella rete locale (quindi con networkmanger, o lanciando un dhclient/dhcpcd eth0), e il gioco è fatto Per collegare più dispositivi alla rete del mio portatile, ho collegato i vari computer (incluso il portatile) allo switch. Nulla di più facile

Ecco che, grazie alle mie doti nell’arte figurativa (eeeh!) e a inkscape, ho creato una mappa della rete, prima e dopo

P.S. Ehi, ho appena fatto 19 anni, sto invecchiando Domani si parte per l’avventura chiamata “università”

frafra Frafra, Guide, Linux connection sharing, dnsmasq, iptables