blogs.ASPItalia.com

Installare Linux (Ubuntu) con PXE e Windows

2010-10-02T15:40:35+00:00

Per memo scrivo questa esperienza. Tralascio cosa mi ha portato ad avere un portatile con il lettore CD non funzionante e senza la possibilità di boot con USB sul quale dovevo installare come nuovo un sistema operativo. In mio soccorso è venuto a PXE, che permette l'avvio del computer via LAN da un server.

Su questo portatile è nata la necessità di installare Linux Ubuntu 9.10 - perché non la 10.04 o, aspettando qualche giorno, la 10.10? Che ne so: così dovevo.

Breve ricerca in Internet e trovo un tutorial che mi sembra utile:

http://hugi.to/blog/archive/2006/12/23/ubuntu-pxe-install-via-windows

Scarico TFTP Server e lo configuro come consigliato:

Creata la directory tftp32 in C:
Copia dell'eseguibile tftpd32 scaricato direttamente dal suo sito.
Avvio e configurazione del programma nel seguente modo:

Nel mio caso, la macchina è sulla porta 192.168.0.4 e il router risponde alla porta 192.168.0.1. Con IP pool starting address ho inserito 192.168.0.9, in modo che il DHCP di questo tool assegnasse alle macchine collegate da questo indirizzo in poi.
Dai server di Ubuntu ho scaricato il file netboot.tar.gz. Con il programma 7-Zip lo decompresso in C:\tftp32.
Da questa directory ho cancellato i file: pxelinux.cfg e pxelinux.0, quindi dalla directory ubuntu-installer\i386 ho copiato la sottostante directory pxelinux.cfg in C:\tftp32, così come il file pxelinux.0.

Con il programma tftpd32 in esecuzione, avvio il portatile che riconosce e raggiunge il mio server PXE e appare la prima schermata dove seleziono l'installazione del sistema operativo. Dopo pochi secondi il portatile riporta un errore e non va oltre. Guardando nel LOG di Tftpd Server vedo questo messaggio:

File <ubuntu-installer\i386\linux> : error 131 in system call ReadFile An attempt was made to move the file pointer before the beginning of the file.

Faccio una nuova ricerca in Internet e trovo che questo problema è comune a molti utenti. Per mio svago inutile prendo i file suggeriti in quel tutorial anche da versioni precedenti di Ubuntu, ma l'errore persiste. Vado oltre, e provo a modificare, senza cognizione di causa, le opzioni di TFTP Server ma sono ancora frustrato per il fallimento.

In un attimo di lucidità arrivo a queste conclusioni:

Il portatile non ha problemi se non il lettore CD, non è il suo PXE ad avere problemi.
Il file linux non è corrotto visto che l'ho preso anche quello di altre versioni.
Il problema sta in tftpd32.

Cerco un altro client per il TFTP, e trovo WinAgents TFTP server. Scarico e installo. Avvio e sembra che non ci siano problemi. Pecco d'ingenuità riavviando il portatile vedendo che non esegue il boot grazie a PXE. Il problema è che quest'ultimo software non ha un DHCP in grado di assegnare un indirizzo alla macchina. Dopo dodici secondi di smarrimento torno a tftpd32 e tra le opzioni vedo che posso avviare solo il DHCP lasciando spento il server TFTP nei settings:

Entrambi i programmi sono avviati e avvio anche il portatile. Nel log del programma TFTP vedo che ora funziona tutto correttamente:

Conferma viene dal portatile che mostra le varie fasi di configurazione e avvia la fase di installazione correttamente: tutto viene installato da Internet e mi ritrovo dopo molto tempo con il portatile installato con gli ultimi aggiornamenti disponibili per quel quella distribuzione.

Un modo come un altro per passare il sabato pomeriggio. Cosa altro avevo da fare visto che in bicicletta ero andato questa mattina? E poi non avevo mai fatto installazioni di sistemi operativi su PC da ethernet.

Tags: Off Topic

Continua a leggere Installare Linux (Ubuntu) con PXE e Windows.

Format date e format number con jquery

2010-08-10T18:42:17+00:00

Il cosiddetto web 2.0, parolona per definire ciò che è possibile da anni e che fa tanto esperti, dovrebbe migliorare l'interattività di un sito web con il suo utilizzatore - ma ha ancora senso definirlo sito web o ormai si può definire a tutti gli effetti applicativi web? Quesito la cui risposta ha lo stesso senso della domanda per me: inutile.

L'interattività grazie a tecnologie come ajax permette la fruizione del contenuto di un sito web, nella volontà del progettista del sito, in modo migliore. Javascript fa la parte da leone e il vero e proprio avvento di jQuery ha aiutato la programmazione con questo linguaggio/tecnologia. E' innegabile: grazie a jQuery la scrittura del codice javascript è più agevole, una volta capita la sua base, e permette un'ottima compatibilità tra i vari browser e il sempre meno ultimo ritocco e test dovuti a funzionalità non compatibili tra i vari browser.

Nelle settimane scorse alla ricerca di un plug-in per jQuery che permettesse la trattazione di numeri e date nel modo più agevole e .net compatibile, mi è stato consigliato questo (link dove si può scaricare anche un esempio per capire le varie funzionalità).

Vediamo un semplice esempio sul suo utilizzo. Ecco il codice html:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>Test number format</title>
    <script src="jquery-1.4.2.min.js" type="text/javascript"></script>
    <script src="jquery.format-1.0.min.js" type="text/javascript"></script>
    <script type="text/javascript">
        $(document).ready(function() {
            var d = new Date();
            var df = $.format.date(d, 'dd/MM/yyyy');
            $("#msg1").html(df);

            var borndate = "02-26-1974";
            var df2 = $.format.date(borndate, 'MM-dd-yyyy');
            $("#msg2").html(df2.toString());

            var value = 1234.56;
            $("#msg3").html($.format.number(value, '#,##0.00'));
            $("#msg4").html($.format.number(value, '#.##0,00'));
            $("#msg5").html($.format.number('1234.56'));

            $.format.locale({
                number: {
                    groupingSeparator: '.',
                    decimalSeparator: ','
                }
            });

            $("#msg6").html($.format.number(value, '#,##0.00'));
            $("#msg7").html($.format.number(value, '#.##0,00'));
        });
    </script>
</head>
<body>
<div>
    <h1>Date</h1>
    <div>
        <span>Visualizza data nel formato dd/MM/yyyy:</span>
        <span id="msg1"></span>
    </div>
    <div>
        <span>Converte stringa in data dal formato MM-dd-yyyy:</span>
        <span id="msg2"></span>
    </div>
    <h1>Number</h1>
    <div>
        <span>Visualizzo numero 1234.56 nel formato #,##0.00:</span>
        <span id="msg3"></span>
    </div>
    <div>
        <span>Visualizzo numero 1234.56 nel formato #.##0,00:</span>
        <span id="msg4"></span>
    </div>
    <div>
        <span>Converto stringa in numero (esempio 1234.56):</span>
        <span id="msg5"></span>
    </div>
    <div>
        <span>Visualizzo numero 1234.56 nel formato #,##0.00 (dopo aver modificato i separatori):</span>
        <span id="msg6"></span>
    </div>
    <div>
        <span>Visualizzo numero 1234.56 nel formato #.##0,00 (dopo aver modificato i separatori):</span>
        <span id="msg7"></span>
    </div>
</div>
</body>
</html>

In esso ho messo tutti gli esempi di base che possono capitare:

Da data a stringa nel formato voluto - per esempio dd/MM/yyyy.
Da stringa a data - per esempio, da MM-dd-yyyy
Numero a stringa nel formato voluto - per esempio #,##0.00.
Conversione da stringa a numero

L'output del codice qui sopra è il seguente:

Date
Visualizza data nel formato dd/MM/yyyy: 10/08/2010
Converte stringa in data dal formato MM-dd-yyyy: Tue Feb 26 1974 20:23:55 GMT+0100 (ora solare Europa occidentale)
Number
Visualizzo numero 1234.56 nel formato #,##0.00: 1,234.56
Visualizzo numero 1234.56 nel formato #.##0,00: 1234.5600
Converto stringa in numero (esempio 1234.56): 1234.56
Visualizzo numero 1234.56 nel formato #,##0.00 (dopo aver modificato i separatori): 1.234,56
Visualizzo numero 1234.56 nel formato #.##0,00 (dopo aver modificato i separatori): 1234,5600

Ok, ho detto tutto quello che volevo dire. anzi no, ma del resto chi vuoi che qualcuno se ne interessi? Ah giusto, è più importante l'esordio della nazionale di Prandelli con il Costa d'Avorio.

Tags: Javascript

Continua a leggere Format date e format number con jquery.

Come si fa a procurarsi un alibi con le webcam (C#/C++/Qt)

2010-08-09T18:13:37+00:00

Dopo che ho inserito, in quell'ammasso di inutilità che è Facabook, una fotografia dove venivo immortalato da una webcam della mia zona mentre ero in bici, una persona, che invece di godersi le ferie e farsi un po' di fatti suoi, mi ha chiesto come avessi fatto.

Innanzitutto non ero d'accordo con nessuno. Ho banalmente scritto un software che ogni n minuti cattura l'immagine di una webcam pubblica e la salva su disco. Prima di partire in bici ho avviato il programmino e al mio ritorno mi sono trovato su disco un centinaio di immagini con quella in cui mi procuravo l'alibi per ieri pomeriggio. Per semplice curiosità, ecco l'immagine catturata (ridotta):

Ovviamente sono poco distinguibile e in un processo non mi basterebbe per evitare la forca. Il software lo avevo scritto in due linguaggi di programmazione: in C# con il Framework .Net di Microsoft, e in C++ con il toolkit Qt. Per semplicità di codice e velocità di realizzazione non c'è paragone ovviamente e l'ago della bilancia si volge verso il C#. Vediamo il codice con questa tecnologia:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Net;
using System.Timers;

namespace WebCam
{
    class Program
    {
        private static System.Timers.Timer _t;
        const string url ="xxx"; // Url dell'immagine della webcam
        static void Main(string[] args)
        {
            Directory.CreateDirectory(Path.Combine(
                AppDomain.CurrentDomain.BaseDirectory,
                "photo"
                ));
            _t = new System.Timers.Timer();
            _t.AutoReset = false;
            _t.Interval = CalcolaIntervallo();
            _t.Elapsed += new ElapsedEventHandler(TakePhoto);
            _t.Start();

            Console.Write("Press 'enter' to exit... ");
            Console.ReadLine();
            _t.Stop();
        }
        static void TakePhoto(object sender, ElapsedEventArgs e)
        {
            System.Drawing.Image imagesource;
            Stream str = null;
            try
            {
                HttpWebRequest wReq = (HttpWebRequest)WebRequest.Create(url);
                HttpWebResponse wRes = (HttpWebResponse)(wReq).GetResponse();
                str = wRes.GetResponseStream();

                imagesource = System.Drawing.Image.FromStream(str);
                imagesource.Save(Path.Combine(
                    AppDomain.CurrentDomain.BaseDirectory,
                    "photo/" +
                    DateTime.Now.ToString("yyyyMMddHHmmss") + ".jpg"));
            }
            catch { }
            _t.Interval = GetIntervall();
            _t.Start();
        }
        private static double GetIntervall()
        {
            DateTime next_date = DateTime.Now;
            next_date = new DateTime(next_date.Year, next_date.Month, next_date.Day, next_date.Hour, next_date.Minute, 0).AddMinutes(1);
           TimeSpan diff = next_date.Subtract(DateTime.Now);
            return diff.Ticks / 10000;
        }
    }
}

Questa console application si basa su un timer che ogni minuto esegue il codice della funzione TakePhoto che con una WebRequest si salva in locale l'immagine del server remoto. Quindi ricalcola quanto tempo dopo il timer deve scattare nuovamente per la prossima immagine.

Le cose con il C++ si complicano, ovviamente anche se il toolkit Qt aiuta molto. Utilizzando gli oggetti di Qt sono obbligato ad utilizzare le sue regole, e scegliendo come tipo di applicativo la console application sono obbligato a utilizzare il QCoreApplication in modo che da poter gestire gli eventi; inizialmente il suo utilizzo comporta delle piccole adattazioni visto che dobbiamo creare una classe che comunichi con esso utilizzando sempre gli eventi. Ecco il corpo del file principale main.cpp:

#include <QObject>
#include <QtCore/QCoreApplication>
#include <QTimer>
#include "webcam.h"
#include <stdio.h>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    webcam wc;
    QObject::connect(&wc, SIGNAL( done() ), &a, SLOT( quit() ), Qt::QueuedConnection);
    QTimer::singleShot(0, &wc, SLOT( takePhoto() ));
    return a.exec();
}

La gestione degli eventi viene implementata grazie ai SIGNAL e SLOT. In questo mio post ne spiego a grandi linee il funzionamento. Dopo la dichiarazione dell'oggetto webcam collego il suo signal done con lo slot quit del QCoreApplication. Dopo il collegamento con il QTimer si avvia la funzione principale di webcam, takePhoto che sarà spiegato dopo. Questo permette di uscire correttamente dal programma alla fine dell'esecuzione della procedura takePhoto in webcam. Ulteriori informazioni si possono trovare qui.

Ecco i due file della classe webcam il primo webcam.h:

#ifndef WEBCAM_H
#define WEBCAM_H

#include <QObject>
#include <stdio.h>
#include <iostream>
#include <qtextstream.h>
#include <qtimer.h>
#include <qnetworkaccessmanager.h>
#include <qnetworkrequest.h>
#include <qnetworkreply.h>
#include <qfile.h>
#include <qurl.h>
#include <qeventloop.h>
#include <qdatetime.h>

#include "thread.h"
using namespace std;

class webcam : public QObject
{
    Q_OBJECT
public:
    explicit webcam(QObject *parent = 0);

signals:
    void done();

public slots:
    void takePhoto();
};

#endif // HELLOWORLD_H

E il file webcam.cpp:

#include "webcam.h"

webcam::webcam(QObject *parent) :
    QObject(parent)
{
}

void webcam::takePhoto() {
    Thread *th=new Thread;
    th->start();
    cout << "Press 'enter' to exit... ";
    QTextStream qtin(stdin);
    QString line = qtin.readLine();
    //th->terminate();
    th->stop();
    th->wait();
    delete th;
    done();
}

La funzione takePhoto istanzia la classe thread. Questa deriva dalla classe QThread e permette di creare un thread parallelo che sarà utilizzato per il download dell'immagine della webcam, thread avviato richiamando la sua funzione start. Quindi scrive nel terminal il messaggio che spiega come terminare il programma e aspetta la pressione del tasto enter prima di distruggere i vari oggetti e richiamato il signal done che, come si ricorderà, essendo collegato all'oggetto QCoreApplication, chiuderà il programma correttamente.

Non rimane che vedere la classe thread. Ecco il file thread.h:

#ifndef THREAD_H
#define THREAD_H

#include <QObject>
#include <QThread>
#include <QDateTime>
#include <QUrl>
#include <QNetworkRequest>
#include <QNetworkAccessManager>
#include <QEventLoop>
#include <QNetworkReply>
#include <QFile>

class Thread : public QThread
{
Q_OBJECT
public:
    explicit Thread(QObject *parent = 0);
    void stop();
    virtual void run();
protected:
    int getInterval();
private:
    QString messageStr;
    volatile bool stopped;
signals:
public slots:
};
#endif // THREAD_H

E il file thread.cpp:

#include "thread.h"

Thread::Thread(QObject *parent) :
    QThread(parent)
{
    stopped=false;
}
void Thread::stop()
{
    stopped = true;
}
void Thread::run()
{
    while (!stopped)
    {
        QUrl url("xx"); // url della webcam
        QNetworkRequest request(url);
        QNetworkAccessManager manager;
        QEventLoop loop;
        QNetworkReply *reply = manager.get( request );
        QObject::connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
        loop.exec();
        QFile file("./" + QDateTime::currentDateTime().toString("yyyyMMddHHmmss")+".jpg");
        file.open(QIODevice::WriteOnly);
        file.write(reply->readAll());
        file.close();
        delete reply;

        QThread::sleep(getInterval());
        //QThread::sleep(10); // only for test
    }
}
int Thread::getInterval()
{
    QDateTime dt=QDateTime::currentDateTime();
    QString qq=dt.toString("yyyy, MM, dd, HH, mm, 00");
    QDateTime dt2=QDateTime::fromString(qq,"yyyy, MM, dd, HH, mm, ss").addSecs(60);
    return dt.secsTo(dt2);
}

Il funzionamento è molto differente con quello scritto in C#: prima veniva utilizzato il timer per l'attesa tra il download dell'immagine, qui un thread che girando continuamente calcola quanto la funzione sleep deve addormentare il thread prima del nuovo download dell'immagine.

La versione in C++ non è proprio perfetta perché alla pressione del tasto enter, prima di chiudere il programma, attende la fine dello sleep della procedura. La cosa si può risolvere con poche righe di codice di controllo, ma il programmino funzionava bene anche così e non avevo alcuna pretesa di perfezione dello stesso viste le mie conoscenza limitate del toolkit Qt.

La salita è questa: link.

Tags: .NET Framework

Continua a leggere Come si fa a procurarsi un alibi con le webcam (C#/C++/Qt).

3D multipiattaforma con QT e Irrlicht

2010-06-02T14:00:00+00:00

Una persona leggendo il mio blog precedente mi ha chiesto informazioni a riguardo di un’immagine inserita come esempio in cui si vedeva una interfaccia tradizionale e una immagine 3D con il logo di Irrlicht. Questa:

Irrlicht è un progetto nato nei primi anni di questo millennio. Permette la creazione di ambienti 2D/3D sfruttando l’accelerazione 3D con l’uso di DirectX e OpenGL. Altro pregio di non poco conto è la sua disponibilità per molte piattaforme: Windows, Linux e Mac. Inoltre Irrlicht supporta una marea di formati file: 3ds Max files, Quake 2 MD2 Models, Maya .obj objects, Quake 3 .bsp maps, Milkshape3D objects, DirectX .x files... Per altri formati 3D sono presenti molti plugins. Inoltre è presente tutto quanto può essere utile per la creazione di un'ambientazione 3D: luci (con nebbia e riflessi), posizione delle camere, animazioni. E' possibile creare ambienti 3D esterni con il rendering del terreno, sia di ambienti interni e molto altro. Conobbi questo progetto alcuni anni fa, quando era presente anche una versione per il suo utilizzo con il Framework .NET: purtroppo questo supporto è stato cancellato nel 2007; sembra che il supporto per il Framework .NET continui in un progetto parallelo, ma non ho mai testato o verificato la bontà di questa iniziativa.

Dopo un mio disinteressamento di questo progetto dovuto a questione di tempo e conoscenze mie limitate nel 3D, ho voluto riprovare l’evoluzione di Irrlicht qualche tempo fa. In contemporanea mi stavo dilettando con il Framework Qt di cui ho parlato nel blog citato prima. Essendo Irrlicht multipiattaforma ho provato a unire i due mondi in un piccolo progetto in C++. Niente di complicato, il tutto si basa su una ambientazione esterna in 3D in cui ci si può muovere liberamente o quasi in cui sono presenti alcune feauture presenti in Irrlicht: oggetti 2D, animazioni, terreno, skybox, gestione delle collisioni e altro. Nel file zip in cui link è presente alla fine di questo post, è presente la versione già compilata per Windows e per Linux, ma non per Mac di cui non me ne frega assolutamente nulla. Una volta lanciato in entrambe i sistemi operativi viene visualizzato la prima windows form con cui si può scegliere se visualizzare il tutto a pieno schermo e il tipo di device per il rendering - OpenGL o due versioni di rendering software, queste ultime due comode in caso ci fossero problemi con il 3D di OpenGL; non ho inserito la voce directx perché non sarebbe in alcun modo utilizzabile su altri sistemi operativi non Microsoft.

Su Linux:

Su Windows:

Una volta cliccato sul button ‘Avvia Demo’ sarà avviato il device 3D e caricati tutti gli oggetti:

E quindi si entrerà nel mondo 3D:

Ho aggiunto anche la visualizzazione di un piccolo help: nella zona di questo cartello è sufficiente premete la barra spaziatrice per avere qualche info. Per iniziare è sufficiente muovere il mouse per guardarci attorno. Infine con i tasti cursore ci si può muovere. Se si volge lo sguardo in alto è già possibile vedere le animazioni gestite da Irrlicht: un pianeta ruota su se stesso e quella che dovrebbe essere il suo satellite girargli attorno:

L’ambientazione è molto semplice. Il personaggio si ritrova in uno specie di canale nel terreno dal quale non può uscire e che lo obbliga ad un percorso prestabilito. Prima di proseguire per l’unica via disponibile, se ci giriamo alle spalle vediamo un altro oggetti di Irrlicht: io li chiamo banalmente sprite. Sono immagini 2D inserite all’interno dell’ambientazione 3D. Hanno la caratteristica di mostrare sempre la stessa immagine da qualsiasi lato la si guardi: se si ricordano i giochi 3D degli anni ‘90 come Doom, Duke Nukem e altri, i cattivoni da sterminare erano realizzati in questo modo:

Se si prosegue per il percorso obbligatorio si giunge in un grande spiazzo a cui al centro è presente una costruzione:

E’ possibile entrare e vedere le opere girando tra le poche stanze:

Per uscire da tutto una pressione decisa sul tasto ESC chiude il tutto.

Ma andando nel tecnico, oggetti all’interno dell’ambientazione 3D sono stati realizzati con Deled, un editor 3D gratuito:

Ho usato vari formati per gli oggetti, dai DMF agli .x di directx e Irrlicht li ha utilizzati senza particolari problemi. Per il terreno Irrlicht usa una banale immagine bitmap in scala di grigi, le quali tonalità creano il dislivello nel terreno 3D quando sarà creato. Nello zip con il progetto è presente l'immagine map.bmp:

La parte con il colore più scuro sarà utilizzato per creare il dislivello (quanto lo decidiamo noi da codice). All’avvio del software il protagonista si trova nella parte inferiore, e risalendo nel percorso si ritrova nel grande spiazzo dove è presente il museo.

Questo progetto, come detto prima, è stato realizzato in C++ con il framework Qt e l’ambiente di sviluppo QtCreator. Per Irrlicht ho dovuto scaricare sia la versione per Windows che per Linux: in quest’ultimo caso ho dovuto ricompilare i sorgenti. QtCreator, come detto nel blog precedente, compila indifferentemente il codice su tutti i sistemi operativi, ma SOLO se si rimane nell’utilizzo degli oggetti di questo framework, nel mio caso per l’utilizzo di Irrlicht ho dovuto utilizzare dei piccoli accorgimenti. Nel progetto ho creato due directory distinte, una per Windows e una per Linux dove ho inserito le .dll/.so per questi sistemi operativi. Quindi ho dovuto modificare il file .pro per la compilazione adatta dipendentemente dal SO:

TARGET = Demo3D
TEMPLATE = app
SOURCES += main.cpp \
    dialog.cpp \
    baseobj3d.cpp \
    scene3d.cpp
HEADERS += dialog.h \
    baseobj3d.h \
    scene3d.h
FORMS += dialog.ui
RESOURCES += Resources.qrc
INCLUDEPATH += ./include
unix:LIBS += -L/usr/X11R6/lib \
    -L./libUnix \
    -lIrrlicht \
    -lGL \
    -lXxf86vm \
    -lXext \
    -lX11
win32:LIBS += ./libWin/libIrrlicht.a
DESTDIR = ./finale

Aggiungendo unix: e win32: è possibile includere determinati file e librerie a seconda se compiliamo con Windows o con Linux. Nel mio caso ho specificato quale librerie (LIBS:) dovevano essere utilizzate. Una piccola nota aggiuntiva per Linux: è indispensabile avere tutta quando necessario per la compilazione sulla propria macchina.

Dopo questo configurazione si potrà compilare sia su Windows che Linux senza alcuna altra modifica al codice e, se tutto è andato a buon fine, ritrovare i file compilati nella directory finale. In questa directory ho già inserito i vari file come le immagini e gli oggetti 3D da caricare. Nel file scene.xml sono presenti tutti gli oggetti da caricare e come/dove devono essere inseriti nell’ambientazione 3D.

Come sempre, è tutto rose e fiori? No, ci mancherebbe! Con i driver video installati sulla mia versione di Ubuntu ho notato dei problemi nel rendering dell’ambientazione 3D come una più bassa qualità del terreno e altri piccoli problemi; inoltre ho dovuto abbassare le qualità delle texture perché creava ancora problemi di rendering, problema che con Windows non era presente. Inoltre si noterà che durante l’esecuzione di questo software la CPU o uno dei core della CPU è sempre e costantemente al 100%. Questo è voluto perché si deve avere sempre la maggior potenza di calcolo per il render in qualsiasi istante. “Anche quando non si fa nulla?” - Bella domanda.

Irrlicht non è l’unico motore 3D disponibile a tutti liberamente. C’è un’ampia scelta tra una decina di motori (pochi multipiattaforma) di cui forse il migliore è Ogre:

Non ho realizzato la demo e il progetto con Ogre perché per mancanza di tempo non sono mai andato oltre ad uno studio iniziale, e le mie conoscenze passate di Irrlicht mi hanno velocizzato notevolmente nello sviluppo a tempo perso del progettino qui incluso che voleva essere solo un esempio un po’ più complesso del solito per Qt.

Dimenticavo: il progetto lo si può scaricare da questo link.

Tags: Off Topic

Continua a leggere 3D multipiattaforma con QT e Irrlicht.

QtCreator

2010-05-02T18:10:46+00:00

La realtà non è solo Windows. Lo viluppo di un software che sia casereccio o abbia grande aspettative può scontrarsi anche con questa necessità: poter girare anche su altri sistemi operativi. Java in primis, ma anche da qualche tempo il Framework .NET che, grazie a Mono, può girare anche su Linux e Mac, cercano di risolvere questa necessità. Il metodo utilizzato è semplice: dopo la compilazione, creano un eseguibile in bytecode, un linguaggio intermedio, che una macchina virtuale permette di eseguire. Praticamente possiamo far eseguire qualsiasi programma compilato in bytecode su qualsiasi sistema operativo che possiede questa macchina virtuale. Il Framework .NET o Java mettono a disposizione un gran numero di classi per quasi tutte le esigenze che un programmatore può aver bisogno, in modo che il programmatore non si deve scervellare per cercare accessi diretti a funzioni del kernel. Questo porterebbe già un grave problema di interoperabilità visto che, ovviamente, una funzione, per esempio la lettura di un file, è presente in un kernel in un determinato modulo mentre in un altro sistema operativo può essere in tutt'altro posto o non essere nemmeno disponibile. Nel nostro programma abbiamo la necessità di leggere un file? Bene, in C# con il Framework .NET scriviamo:

string content = System.IO.File.RealAllText("nomefile.txt");

Girando sul sistema operativo Windows, la Virtual machine tradurrà questa richiesta con il sottoinsieme di funzioni presenti nel Kernel del sistema operativo per leggere il file in questione; lo stesso codice, girando su Linux, non dovrà essere modificato e personalizzato per questo sistema operativo, e ci penserà Mono a tradurre la richiesta di lettura del file con le corrette richieste al Kernel di Linux. I benefici sono facilmente comprensibili visto che non c'è alcuna perdita di tempo nel convertire nessuna riga nel nostro codice per permettere la corretta esecuzione del nostro software su più sistemi operativi. La semplicità dell'esempio qui sopra non deve però illudere: un software non si basa sempre per chiamate semplici ma spesso anche con procedure proprie della macchina su cui gira. Una windows forms come quella di cui ho postato un esempio qualche tempo fa, in ambiente Mono emula l'aspetto e il funzionamento delle finestre di Windows:

Possiamo utilizzare anche librerie presenti per i sistemi operativi di nostro interesse. Qui avevo parlato per esempio delle GTK che girano perfettamente sia su Windows che su Linux - su Mac non lo so, perché di questa macchina non me ne frega nulla. Già molti software utilizzano questa strada, uno tra tanti Pidgin, il programma di messaggistica istantanea presente su molti sistemi operativi - anche se qui non si parla di Mono/java, ma ricompilazione del codice per le macchine interessate. Ed è proprio su questo punto che volevo andare a parare con questo mio post.

Il Qt toolkit, sviluppato dalla QT Software - prima Trolltech e in parte sovvenzionata da Nokia - è un framework che gira sui principali sistemi operativi: Windows, Mac e Linux (e altri SO per dispotivi mobili). Non è solo una libreria grafica, ma un framework completo che permette la gestione dei file, xml, tcp, database, grafica 2D, 3D con le OpenGL, audio e altro. E' utilizzabile con molti linguaggi, dal C++ al Python e Java. Da quel che ne so io, era nato un progetto per il loro utilizzo anche on il Framework .NET, ma da quel che ho letto sembra che tale progetto sia fermo... felice di essere smentito. Forse in ambiente Windows, Qt non è molto conosciuto, ma basti sapere che in ambiente Linux, insieme alle GTK su cui su basa il desktop manager Gnome, è molta conosciuta e utilizzata visto che su di essa si basa il secondo desktop manager più utilizzato, Kde. In ambiente Windows il software più conosciuto che utilizza questo toolkit è VLC, il programma per la visione di qualsiasi formato audio e video. Inoltre Nokia sta puntando molto su questa tecnologia per il suo sistema operativo Symbian per dispositivi mobili, dunque si presenta un probabile futuro roseo visto la posta in gioco di un mondo del portabile in continuo fermento per le numerose notivà (l'argomento meriterebbe una trattazione a sé, ma la voglia non c'è e dunque non ci provo nemmeno).

Oltre al toolkit è disponibile un ambiente di sviluppo integrato dal nome Qt Creator. Oltre all'editor di risorse come interfacce grafiche, possiede al suo interno un ambiente di sviluppo basato sul C++. Scaricabile gratuitamente la versione LGPL si ha a disposizione un editor completo per le interfacce grafiche e per la scrittura del codice C++ con tanto di intellisense, come detto, un debugger e se scaricata la versione SDK, anche la documentazione completa. Va innanzitutto detto che per la versione per Linux, si deve installare manualmente il compilatore g++. Nulla di difficile: nel caso di Ubuntu è sufficiente installare il macro pacchetto build-essential per avere già a disposizione tutto il necessario. Su Windows viene installato di default la versione per questo sistema operativo di mingw, che non è altro che la versione per questo sistema operativo del compilato c++, linker e altri strumenti. Dopo l'installazione saranno presenti anche numerosi esempi ben documentati per le principali funzioni messe a disposizione dal toolkit Qt. Nelle demo è impressionante trovare anche un browser con tanto di flash funzionante basato sul webkit - maggiormente compatibile con gli standard di IE; dunque se avete la necessità di personalizzare il browser secondo le proprio necessità ora si può partire da una base già bella pronta:

Gli esempi preposti si possono dividere in due macro categorie: tutorial con codice completo e vere e proprio demo. Nei primo si possono trovare esempi anche semplici, utili per impratichirsi con questo toolkit, nelle demo troviamo esempi con codice sorgente molto più avanzi, come il browser qui sopra o altri, come il tool grafico seguente che mostra alcune potenzialità grafiche:

Ma i vantaggi, come ho cercato di dire precedentemente, non si basano solo sulla potenzialità di questo framework, da dalla compatibilità che possiamo avere, senza il minimo sforzo - o ridotto al minimo, per vedere il nostro codice ricompilato su altre macchine e vedere il tutto funzionare. Tra gli esempi troviamo quello che mostra l'utilizzo delle Multiple document interface (MDI). Su Linux in Gnome:

Stesso codice ricompilato su Windows:

Dialog con tab su Linux:

Su Windows:

Un semplice Address book su Windows:

Su Linux:

Tra gli esempi si trova codice utile per qualsiasi scopo: dal 2D, alle utility per uno screenshot:

Anche esempi per il Drag & drop, per la gestione dei file, della System tray, per la visualizzazione di chart; su Windows:

Su Linux:

Ma non solo, anche esempi sull'utilizzo di database, tcp, socket, e molto altro. Si è visto prima l'esempio di un browser completo, anche un client Torrent è disponibile con tanto di codice e perfettamente funzionante:

E sempre da questo framework, possiamo gestire/ascoltare anche gli MP3:

Per esigenze mie, che non sto a spiegare perché sono fatti miei, ho iniziato a utilizzare le Qt e dopo i primi problemi con la sintassi del C++ non più utilizzata da anni, mi sono trovato presto a mio agio: spesso mi sono trovato dinanzi a oggetti che ricordano da vicino il Framework .NET o Java. Per esempio, per l'utilizzo di stringhe, già facilitata in C++ grazie alle STL che ci permette di scrivere:

#include <string>
using namespace std;
...
string name="AZ";

Con le Qt abbiamo a disposizione la classe QString:

#include <QString>
...
QString name="AZ";

Nella quale troviamo tutte le funzioni di cui un programmatore normalmente ha bisogno: replace, substring, find, startWith, endWith e così via. E la vicinanza che io ho trovato con gli oggetti del Framework .NET, la si può vedere nella gestione delle liste. Quello che scriviamo in C#:

List<string> coll=new List<string>();
coll.Add("AZ");
coll.Add("...");
string name=coll[0];

Con le Qt in C++:

QList<QString> coll;
coll.append("AZ");
coll.append("...");
// Oppure:
// coll << "AZ" << "...";
QString name=coll.at(0);

Per le varie conversioni tra oggetti, sono presenti i vari metodi:

QString str="12";
int num=str.toInt();

Oppure il più generico oggetto QVariant che ci permette il travaso tra i vari oggetti del Framework Qt. Altro oggetto molto utilizzato per la gestione delle date è il QDateTime:

QDateTime dt = QDateTime::currentDateTime();
QDateTime xmas(QDate(dt.date().year(),12,24), QTime(17,00));
int secToXmas = dt.secsTo(xmas);

Se si vuole scrivere un file:

#include <QTextStream>
#include <QFile>
int main()
{
QFile data("myfile");
if (data.open(QFile::WriteOnly)) {
QTextStream out(&data);
out << "Contenuto file di testo" << endl;
}
}

Per leggere:

QFile dataread("myfile");
if (dataread.open(QFile::ReadOnly)) {
QTextStream in(&dataread);
QString content=in.readAll();
dataread.close();
}

Per la gestione delle directory c'è QDir:

QString home = QDir::homePath();

Per avere la lista presenti:

#include <iostream>
#include <QTextStream>
#include <QDir>
int main(int argc, char *argv[])
{
QDir dir;
QStringList filters;
filters << "*.exe" << "*.cpp";
dir.setNameFilters(filters);
QFileInfoList list = dir.entryInfoList();
for (int i = 0; i < list.size(); ++i) {
QFileInfo fileInfo = list.at(i);
std::cout << QString("%1").arg(fileInfo.fileName()).toStdString();
std::cout << endl;
}
return 0;
}

Ho trovato anche ben fatto la gestione del multi language: grazie a dei file Xml si possono definire le label che da codice possiamo caricare e visualizzare grazie al metodo tr():

<!DOCTYPE TS><TS>
<context>
<name>FirstPanel</name>
<message>
<source>Example</source>
<translation>Esempio</translation>
</message>
...
</context>
<context>
<name>SecondPanel</name>
<message>
<source>Code</source>
<translation>Codice</translation>
</message>
...
</context>
</TS>

Il file xml può contenere anche più sezioni di codice come si vede sopra. Per poter richiamare il testo:

QApplication app(argc, argv);
QTranslator translator=translator.load(QString("nomefile"));
app.installTranslator(&translator);
QString source=tr("Example");

Nella gestione delle interfacce grafiche mi sono immediatamente scontrato con un utilizzo alternativo degli eventi. Le Qt introducono un nuovo modo per la comunicazione di oggetti: i signals e gli slots. Avendo un pulsante nella windows application, se vogliamo che al click di un button sia eseguito il nostro codice, doabbiamo collegare il signal del click del button ad uno slot presente nel codice (anche se è possibile farlo da interfaccia grafica). Per esempio, avedo un QButton e una QLabel (tutti gli oggetti all'interno di questo Framework iniziano con la lettera Q) nell'interfaccia grafica:

connect(ui->ButtonAZ, SIGNAL(clicked()), this, SLOT(ChangeTextAZ()));

connect crea il collegamento al click sul button al metodo ChangeTextAZ presente all'interno della stessa classe (this) dell'interfaccia grafica. Al click sul button sarà richiamata la funzione apposita - per esempio:

void MainWindow::ChangeTextAZ()
{
QString cc=QDateTime::currentDateTime().toString();
ui->label->setText(cc);
}

Per scollegare uno slot dal signal:

ui->ButtonAZ->disconnect(SIGNAL(clicked()));

Sia ben chiaro da subito che il loro utilizzo non si limita agli eventi dei button nella pagina, ma anche ai singoli oggetti creati da noi. Per esempio, la classe scritta in C++ nel seguente modo:

class Person
{
public:
Person() { Age=0;}
int GetAge() { return Age; }
void setAge(int age) { Age=age;}
private:
int Age;
};

Scritta utilizzando gli oggetti di Qt con il supporto dei signals e slots, diverrebbe:

#include <QObject>
class Person:public QObject
{
QObject // macro per l'inclusione degli oggetti per l'utilizzo delle funzionalità aggiuntive di Qt
public:
Person() { Age=0;}
int GetAge() { return Age; }
signals:
void changeAge(int age);
public slots:
void setAge(int age)
{
if (Age!=age)
{
Age=age;
emit changeAge(age);
}
}
private:
int Age;
};

Ho aggiunto il signal changeAge e modificato la funzione setAge impostandolo come slot. Questo mi permette di collegare questo oggetto ad eventi che possono essere lanciati da un altro oggetto collegato. Se usiamo il codice seguente:

Person a,b;
connect(&a, SIGNAL(changeAge(int)), &b, SLOT(setAge(int)));
a.setAge(36);
int c=b.GetAge(); // i conterrà 36

Creati due oggetti, a e b, e collegati, assegnando il valore intero 36, la funzione setAge controllerà inizialmente che non sia già stato assegnato questo valore (per evitare loop), altrimenti modificherà la variabile intera Age e scatenerà l'evento ChangeAge grazie a emit che, collegato al setAge dell'oggetto B, ne modificherà il valore.

Come detto in precedenza, possiamo utilizzare qualsiasi editor per l'utilizzo del framework Qt, anche Visual Studio con questo add-in. Se vogliamo un editor che sia cross-platform possiamo utilizzare anche Eclipse, oppure l'editor nativo delle Qt: QtCreator. Disponibile per Windows, Mac e Linux, è un ottimo e leggero editor che comprende debug, help e intellisense nella stesura del codice, e comprende un buon editor per la creazione delle interfacce grafiche. Su una macchina con Linux (Ubuntu 9.10) ho potuto utilizzarlo senza particolari problemi con una macchina con soli 512MB; con Windows è utilizzabile con quantitativi di ram minimi; su Mac non l'ho provato perché non me ne importa niente di tali macchine. Se dovessi confrontarlo con altri editor come Visual Studio (uno dei pochi ambienti di sviluppo che conosco bene), il QtCreator paga pegno per l'intellisense non al livello di Visual Studio: nella visualizzione dei metodi non si ha alcun aiuto del tipo il numero di parametri, overload ed eventuali tipi restituiti:

L'help è di buon livello, ma spesso si trovano poche righe di descrizione e nessun esempio sull'utilizzo. Il debug fa il suo lavoro:

E anche la gestione dei thread in debug è buono anche se inferiore all'attuale presende in Visual Studio 2010. L'editor delle interfacce grafiche è ben fatto e, capite le basi di Qt, permette la creazione di qualsiasi interfaccia:

In cantiere è già presente il nuovo editor, la versione 2.0, che introdurrà molte novità, tra le quali il QML (Qt Meta-Object Language) che permette la creazione di interfacce grafiche in un meta linguaggio interno molto seplice e le Qt Declarative Module e altre novità; per una lista completa si veda questo link.

Ok, dopo questa breve divagazione, la domanda lecita potrebbe essere: "Ma quanto pesa tutto ciò negli eseguibili?". Su Linux praticamente nulla visto che le Qt sono installabili dai repository e nel caso di Kde sono già installate di default. Su Windows la risposta è il solito e stancante dipende! Dipende da quanti e quali oggetti del Framework Qt vengono utilizzati. Per una mia windows application ho dovuto includere nella directory dell'eseguibile i seguenti file:

QtCore4.dll (2.359 Kb)
QtGui4.dll (9.293 Kb)
QtXml4.dll (389 Kb)
libgcc_s_dw2-1.dll (42 Kb)
mingwm10.dll (12 Kb)
qjpeg4.dll (188 kb)

Qui parlo di un piccolo problema che avevo riscontrato all'esecuzione di tale codice su Windows. Inizialmente installato tale software su un'altra macchina con Windows Vista non mi venivano visualizzate le immagini. Solo dopo scopro che è necessario utilizzare la dll qjpeg4. Secondo la documentazione la inscerisco nella directory dove c'è l'eseguibile, più precisamente, in plugins\imageformats, e mi accorgo che le immagini non vengono ancora visualizzate. Solo dopo una ricerca in internet, scopro che è necessario aggiungere il file di configurazione nella stessa directory dell'eseguibile, con il nome qt.conf e con questo contenuto:

[Paths]
plugins=./plugins

Questo problema sotto Linux non c'è. Comunque, aggiungendo che l'esegubile era per il mio esempio sotto al mega, il tutto si è risolto in circa 12 MB - l'applicativo d'esempio era una windows forms con effetti 2D e gestione di foto e dati informativi personali. Per applicazioni che devono diversificare il tipo di compilazione e inclusioni oggetti specifici del sistema in cui gira, è sufficiente mettere mano al file nomeprogetto.pro:

TARGET = Esempio
TEMPLATE = app
SOURCES += main.cpp \
objects.cpp
HEADERS += objects.h
FORMS += dialog.ui
RESOURCES += Resources.qrc
INCLUDEPATH += ./include
unix:LIBS += -L/usr/X11R6/lib \
-LMySharedClass
win32:LIBS += ./MySharedClass.a
DESTDIR = ./final

Precedendo con win32: o unix: possiamo specificare, nell'esempio sopra, quale library includere utilizzare nel caso di Windows (nel primo caso) o di Linux (nel secondo) - è presente anche macx: per la cronaca... Con questo trucchetto possiamo anche includere anche i nostri file .cpp da compilare dipendentemente dal sistema operativo su cui sarà compilata l'applicazione:

win32 {
SOURCES += hellowin.cpp
}
unix {
SOURCES += hellounix.cpp
}

Magari in futuro pubblicherò un esempio completo di un'applicazione scritta in Qt compilabile sia su Windows che Linux senza alcuna modifica che sfrutti librerie esterne.

Un'altra domanda lecita potrebbe essere: "Quanto è performante il codice compilato con questo ambiente di sviluppo se confrontato con quello prodotto dai compilatori in Visual Studio?". Sinceramente non ho mai trovato documentazione a riguardo e i test banali fatti personalmente non mi hanno dato alcuna risposta valida a questo quesito.

Un altro pregio che ho trovato nel mondo Qt, è la ricca documentazione che si può trovare sia sul sito ufficiale che in molte altre community. Per esempio, cito la internazionale Qt Centre. In Italia una giovane community si è affacciata da poco tempo e propone già dei buoni contenuti per la lingua Italiana.

Basta, ho scritto troppo. Si può però capire come questo framework mi sia piaciuto. Non ho potuto scoprire tutto l'immenso mondo nascosto dietro alle due lettere Qt causa il poco tempo libero che ho potuto dedicare alla semplice scoperta di questa tecnologia, ma darei un voto molto alto - naturalmente è un parere completamente PERSONALE, dunque di eventuali critiche non me ne frega niente.

Ma dunque è tutto oro quel che luccica? No. Ho riscontrato vari problemini, alcuni dei quali citati prima. Innanzitutto, nella versione per Windows ho notato strane anomalie dell'ambiete di sviluppo QT Creator. Per esempio, su un portatile con Windows XP ho riscontrato errori nella ricompilazioni dei sorgenti presenti negli esempi, oppure l'help non funzionante - con Linux/Ubuntu invece nessuno di questi problemi. Inoltre con codice C++ scritto non utilizzando gli oggetti di Qt, ho notato blocchi casuali del debugger su entrambi i sistemi operativi (ma questo potrebbe essere dovuto a qualche sciocchezza scritta da me: la mia poca esperienza in C++ potrebbe esserne la causa principale).

Inoltre ho notato che il compilatore va in confusione nel caso che ho descritto nell'esempio qui sopra riguardante l'oggetto che si interfaccia con i signals e slots. Sempre casualmente, se si scrive un proprio oggetto e si aggiunge in un secondo tempo il supporto e l'inheritance a QObject, il compilatore non riesce a riconoscere questo nuovo oggetto ed emette l'errore: "Undefined reference to vtable". Da quel che ho visto il problema è dovuto dal fatto che QtCreator aggiunge un file con il moc_nomeclasse.cpp che viene creato solo se all'aggiunta nell'ambiente di sviluppo di tale classe viene subito definito l'inheritance con QObject; l'unica soluzione è cancellare tale classe, con i relativi file, e aggiungerla nuovamente al progetto.

Ora attendo la nuova versione sia di QtCreator che del Framework stesso dove importanti novità saranno introdotte. Basta mi fermo qui, perché altrimenti mi viene voglia di spalare ***** su altre tecnologie... So che ho solo sfiorato l'argomento Qt, e che sicuramente ho tralasciato molti altri aspetti importanti. Ma - è un mio punto di vista - la trasportabilità del codice e poterlo riutilizzare su più piattaforme è - e sarà - sempre più importante, senza dover riscrivere ogni volta parte del codice o reimplementare funzioni dello stesso. Il mondo non è solo Windows, e due...

Naturalmente tutto quanto esposto qui, è sotto licenza IMHO! Il mio tempo libero lo utilizzo come mi pare. Oggi in Spagna ha vinto Lorenzo in motogp e tra sette giorni inizia il giro d'Italia finalmente; oggi piove ed ho i tergicristalli della macchina rovinati da parecchio tempo e non ho avuto ancora il tempo di cambiarli.

Tags: Object Oriented Programming, Visual Studio

Continua a leggere QtCreator.

Office 2010 e i formati aperti

2010-04-22T17:49:52+00:00

Vediamo se funziona ancora il mio blog. Sempre molto assente sono. Peccato. Oggi è stato un giorno di test. Uscito Office 2010 è stato subito installato e testato anche se lo conoscevo da qualche mese visto che lo seguo dalla versione beta. Ne approfitto oggi per l'installazione sulla macchina di lavoro e mi trovo una richiesta all'avvio che non avevo mai visto nelle versioni in fase di sviluppo:

Troppi processi hanno fatto in modo che venisse chiesto anche in Office quale formato usare di default? Office o OpenOffice/ODF? Ottima cosa.

Tags: Off Topic

Continua a leggere Office 2010 e i formati aperti.

Anno (quasi) nuovo, layout nuovo

2009-12-30T13:42:37+00:00

Qualche tempo fa avevo festeggiato i dieci anni. in questi giorni di meritato riposo ne ho approfittato per rifare il layout del sito in questione: dopo otto anni era giunto il momento di qualche cambiamento.

Ne è valsa la pena? Ma chi lo sa. Auguri 2010!

Tags: Off Topic

Continua a leggere Anno (quasi) nuovo, layout nuovo.

Mono e Framework... un po' di semplici benchmark parte seconda

2009-11-16T20:45:00+00:00

Poco più di un anno fa avevo scritto un blog dove avevo confrontato le prestazioni di una windows forms scritta in .net su una macchina con Windows XP e una macchina Linux con la versione 1.9 di mono. In questi mesi Mono ha raggiunto la versione 2.4 e gode di ottima salute malgrado ci siano i soliti estremisti che solo all'idea di una tecnologia portata dal mondo Microsoft stanno male. Anche se sempre un paio di versioni indietro da ciò che il Framework offre su sistemi operativi Microsoft, siamo ormai giunti anche al supporto di Linq, di cui potrei parlare in un blog futuro sempre se ne avrò voglia. Per questo lunedì sera mi accontenterò di rifare lo stesso test di un anno fa con l'ultima versione di Mono che gira sull'ultima versione di Ubuntu (9.10) e sempre sulla stessa macchina. Ecco il risultato della piccola applicazione la cui descrizione delle operazioni che esegue ho spiegato nel blog prima citato:

Stupito. Per quanto può valere questo banale test nel calcolo degli interi e dei doublele prestazioni sono migliorate nettamente, ma anche a confronto della versione originale del Framework che gira su Windows:

	Integer	Double	Xml 1	Xml 2
Windows .net	453,125s	1859,375s	46,875s	4640,625s
Mono 1.9	499,71s	2362.398s	259,891s	26959,493s
Mono 2.4	286,46s	1314,403	475,253	23604,915

Grande velocità nella trattazione dei numeri ma nella gestione dei file e xml fa ancora parecchio schifo.

Tags: .NET Framework, Mono

Continua a leggere Mono e Framework... un po' di semplici benchmark parte seconda.

SCRIBEFIRE4DSteutfocSCRIBEFIRE

2009-11-16T01:52:48+00:00

SCRIBEFIRExsxNtSEySCRIBEFIRE

Tags: Off Topic

Continua a leggere SCRIBEFIRE4DSteutfocSCRIBEFIRE.

[OT] GMail pensasse ai suoi bug, non alla meteorologia

2009-11-10T17:21:42+00:00

Selezionando un tema casuale mi sono ritrovato questa sorpresa collegato alla situazione meteo attuale:

Di seguito:

E infine:

Però non riesco a togliere nei nomi dalla rubrica nella pagina. Ci dovrebbero essere priorità, non solo visive per bimbominkia - IMHO.

Tags: Off Topic

Continua a leggere [OT] GMail pensasse ai suoi bug, non alla meteorologia.

[OT] Auguri per i 10 anni a me...

2009-10-31T10:20:54+00:00

Era la seconda metà dell'ottobre 1999 quando pubblicai su un hosting free la prima versione del mio sito del ciclismo. Ricordo che lo feci con Frontpage. In tutto erano una decina di pagine in HTML. L'idea era nata a me e mio fratello dall'idea di condividere le proprie decennali esperienze ciclistiche per le salite presenti nella mia zona. Ricordo che le prime altimetrie erano realizzate su foglio con righello e matita e poi scannerizzate :)

Nel novembre di quell'anno iniziò la sua conversione in vbscript/asp che terminò completamente nei primi giorni di dicembre con una nuova interfaccia basata sui frame: titolo e menu a sinistra sempre presenti e parte centrale con il contenuto. Nel 2001 la nuova veste grafica e il passaggio, nella seconda metà dell'anno, in ASP.NET 1.0. I contenuti aumentarono continuamente fino all'implementazione con Livio dell'archivio delle salite d'Europa. Poco dopo il passaggio ad ASP.NET 1.1 e infine alla 2.0. Il database è sempre stato Access, e per ora ha sempre retto bene anche nei periodi di grande traffico.

Va be', fine dell'autocelebrazione. So solo che da quel lontano 1999 non avrei mai pensato di festeggiare il decimo anno di quel mio sito completamente amatoriale...

Tags: Off Topic

Continua a leggere [OT] Auguri per i 10 anni a me....

SqLite vs Access vs Sql Ce 3.5

2009-10-24T19:23:34+00:00

Per riprendere confidenza alla programmazione dopo un periodo di riposo forzato, ho messo mano in questi giorni al mio sito per ottimizzare il codice e per nuove implementazioni che da troppo tempo erano in cantiere. A parte la primissima versione del sito che era fatta completamente in html senza nessun supporto server side, nella sua implementazione prima con il classic asp e poi con asp.net, si è sempre basato sul database Access. Tuttora sono due i database che tengono in piedi il tutto senza grosse fatiche e il minimo uso di cache presente ha permesso che non ci fossero rallentamenti e problemi dovuto ad un uso massiccio di questo tipo di database.

Proprio durante la fase di sviluppo di questi giorni è nata l'idea di prendere in considerazione anche altri database. Innanzitutto, essendo il sito su un hosting povero, non ho a disposizione database degni di questo nome come Sql Server o MySql, e arrangiarsi alla bell'e meglio è ciò che mi ha obbligato a guardarmi attorno alla ricerca di alternative e, perché no, mi ha permesso di prendere confidenza con qualcosa di nuovo. Pensandoci bene, a parte la mia esigenza personale dettata dal mio sito e viste le alternative possibili, è proprio obbligatorio passare ad hosting più costosi per siti con basso traffico solo per avere un database serio quando il numero di richieste pagine/query è talmente basso da far apparire addirittura sprecato un hosting con Sql Server o MySql? In fondo, se uno prende uno spazio di hosting per inserire un proprio blog o come contenitore di informazioni personali, dunque con una previsione almeno iniziale di carico molto basso, anche Access può far degnamente il suo lavoro. Ma perché non prendere in considerazione anche altre alternative?

In questo blog voglio solo trascrivere le mie sensazione nell'uso e di test personali nell'uso di tre database utilizzabili nelle proprie medio piccole web application:

Access
SqLite
Sql CE

Access per i più non ha bisogno di presentazione. Prima o poi lo incontrano tutti nel loro percorso informatico. Probabilmente il più facile database disponibile ed è facilmente utilizzare fin dai tempi del classic asp: è sufficiente prendere il file del database (.mdb) e copiarlo in una directory sul server, e senza alcun'altra installazione sul server, si può interrogare da codice con poche righe di codice. I suoi difetti maggiori sono le prestazioni e l'impossibilità di usarlo in multiutenza. Per le web application il problema maggiore rimane solo il primo visto che se in lettura molte pagine possono accedere contemporaneamente, in scrittura solo un'operazione alla volta è possibile.

La connessione, avviene grazie ai driver ole-db, e il Framework mette a disosizione un namespace apposito: System.Data.OleDb, con tutta la sua sequenza di classi:

OleDbConnection
OleDbCommand
OleDbDataAdapter
OleDbDataReader
...

E utilizzare questa stringa di connessione: "Provider=Microsoft.Jet.OLEDB.4.0;Data source=database.mdb":

OleDbConnection conn=new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data source=database.mdb");

SqLite è un progetto completamente free e può essere utilizzato per qualsiasi tipo di applicazione. Per utilizzarlo nelle proprio web application in asp.net, è sufficiente copiare il file System.Data.SQLite.dll nella directory bin (o creando una refernce da Visual Studio). Come Access, anche questo database di basa su un file che ha come suffisso ".s3db". Per creare questo database sono presenti numerosi progetti free, io ho utilizzato il famoso SqLite Administrator:

SqLite per il framework è possibile scaricarlo da questo link. Una volta installato è possibile trovare i file di nostro interesse nella directory:

C:\Programmi\SQLite.NET\bin

Oltre alle dll possiamo trovare anche un test di esempio per l'utilizzo di questo database e la documentazione. Inoltre possiamo integrare il designer di SqLite direttamente in Visual Studio e con Linq.

SqLite è utilizzabile dai progetti scritti con il Framework dal namespace System.Data.SQLite che mette a dispozione le classi apposite:

SqLiteConnection
SqLiteCommand
SqLiteDataAdapter
SqLiteDataReader
...

La stringa di connessione è "Data Source=database.s3db". Per esempio:

SqLiteConnection conn=new SqLiteConnection("Data Source="+Request.MapPath("database.s3db"));

Anche se non rientra nei canoni dell'obbiettivo di questo blog ho preso in considerazione anche Sql CE di Microsoft. Se si utilizza per lo sviluppo Visual Studio, probabilmente lo si ritroverà all'interno della propria macchina. Altrimenti è possibile scaricarlo gratuitamente da questo link. La creazione e la gestione delle tabelle è molto semplice visto che è possibile manipolare i file di database di Sql CE (con suffisso ".sdf") con gli editor di Sql Server, o con il gratuito Microsoft SQL Server Management Studio Express. Qui sotto la banale operazione di creazione di un database di questo tipo con il Sql Server Managment Studio della versione 2008:

Come scritto sopra, non rientra nei canoni della mia valutazione perché per inserire questo tipo di database su un server in hosting per la propria web application, non è sufficiente copiare le dll ma deve essere installato direttamente sulla macchina. A queste conclusioni sono giunto dopo numerosi tentativi andati a vuoto e dopo una veloce ricerca in rete di una soluzione. Se qualcuno sa una strada che può portare alla soluzione è benvenuta qualsiasi informazioni in merito.

Inserita la reference a "System.Data.SqlServerCe" nella web application abbiamo il namespace apposito e le classi per la manipolazione di questo database:

SqlCeConnection
SqlCeCommand
SqlCeDataAdapter
SqlCeDataReader
...

La stringa di connessione è uguale a quella che per SqLite: "Data Source=database.sdf". Per esempio:

SqlCeConnection conn=new SqlCeConnection("Data Source="+Request.MapPath("database.sdf"));

Se si prova ad utilizzare Sql CE in una web application si ha inizialmente una sorpresa trovandosi di fronte all'errore:

"SQL Server Compact Edition is not intended for ASP.NET development"

La soluzione si basa nell'aggiunta di questo riga di codice:

AppDomain.CurrentDomain.SetData("SQLServerCompactEditionUnderWebHosting", true);

Per i miei test ho utilizzato due semplici tabelle con una relation, aventi questa struttura:

FirstName e Information sono campi varchar, Age è un campo numerico così come ParentId che lega i record della tabella "Table2" ai record presenti in "Table1". Il test si basa sulla scrittura di centiana di record alla volta e a delle query di lettura su questi record in modo ripetuto.

Il primo test si basa sulla scrittura di dieci record nella prima tabella e di trenta nella seconda. Oltre la scrittura, dopo l'inserimento della prima tabella, viene letto l'Id generato dalla tabella per creare il giusto riferimento nella tabella figlia. Qui sotto riporto i tre database:

N. tentativi	Access	SqLite	SqLite - T	Sql CE 3.5
1°	0s 93	8s 53	0s 40	0s 73
2°	0s 98	8s 25	0s 47	0s 74
3°	0s 93	8s 70	0s 46	0s 71

Ho dovuto inserire in due colonne i tempi di SqLite a causa delle prestazioni scadenti di questo database se non utilizziamo procedure apposite per questo tipo di operazione. Il codice di test per l'inserimento di tutti i database si basa su un banale ciclo for. All'interno di esso eseguo l'apertura della connessione del database, quindi una a una le singole operazioni di scrittura. Pressappoco questo schema:

for (int i=0;i<10;i++)
{
// Apri connessione
// Esegue inserimento in tabella 1
// Legge l'ID inserito dal database per l'inserimento
for (int x=0;x<30;x++)
{
// Inserisce record nella tabella 2
}
// Chiude connessione
}

Grazie a questo codice ci si scontra ad un grosso limite di SqLite che, nelle operazioni di grande inserimento, si scontra con un crollo di prestazioni notevole. Per evitare questo problema, è sufficiente mettere le varie fasi di inserimento in transaction per avere quel balzo di prestazioni che lo porta al primo posto nella tabella precedente (colonna "SqLite - T"). Il codice qui sopra va riscritto in questo modo:

for (int i=0;i<10;i++)
{
// Apri connessione
// Apri transaction (invio comando "begin")
// Esegue inserimento in tabella 1
// Legge l'ID inserito dal database per l'inserimento
for (int x=0;x<30;x++)
{
// Inserisce record nella tabella 2
}
// Chiususa transaction (invio comando "commit")
// Chiude connessione
}

Anche se i distacchi sono limitati, Access risulta il più lento e SqLite il più veloce anche se, abbiamo dovuto ottimizzare il codice appositamente per lui. Di seguito ho eseguito delle operazioni ripetute in lettura. Le tabelle, composte da trenta record la prima e novecento la seconda, vengono lette la prima per n volte, e la seconda viene conteggiata in una query il numero di record. I risultati sono i seguenti:

N. tentativi	Access	SqLite	Sql CE 3.5
1°	2s 49	0s 31	1s 33
2°	2s 34	0s 23	1s 25
3°	2s 35	0s 23	1s 26

Qui non c'è storia: SqLite fa la differenza. Access è l'ultimo con distacchi abissali. L'ultimo test di lettura esegue ripetute query con join tra le due tabelle.

N. tentativi	Access	SqLite	Sql CE 3.5
1°	3s 88	0s 96	2s 55
2°	3s 99	0s 97	2s 55
3°	3s 91	0s 96	2s 67

Si possono tirare delle conclusioni? No. Anche se l'informatica si avvicina moltissimo alla matematica è soggetta alla regola che vige in politica e sport dove chiunque può dire il contrario di tutto solo per partito preso. E siccome a me non me ne frega nulla e so che là fuori c'è sempre qualcuno che si sente il diritto di criticare, ognuno tiri le conclusioni per sé. Anzi, consiglio di fare delle prove e valutare. Le banderuole si muovono a seconda di dove tira il vento, e non hanno cervello. Altri lo hanno, deturpato o meno, ma è più comodo sventolare per simpatie personali.

E siccome non me ne frega nulla - questa frase non varrebbe nulla se non dessi un mio parere personale, perché se non lo facessi vorrebbe dire che mi importerebbe - ecco un mio giudizio: SqLite è leggero ed ha ottime prestazioni, lo prenderei in considerazione per piccole web application tenendo sempre d'occhio le varie ottimizzazioni per evitare inconvenienti come quello della scrittura che ho citato. Access si può definire finito nelle web application? Nì: le alternative ci sono e se si vuole dirla tutta, se proprio si vuole un database degno di tal nome perché si prevedono necessità pesanti, senza dover andare su Sql Server, ormai tutti i servizi di hosting anche economico danno MySql con un piccolo sovrapprezzo. L'importante è sapere che sino alternative. In ogni caso rimando per approfondimenti sui vari database che ho trattato alla numerosa documentazione che è reperibile in Internet - se con questo mio blog ho acceso un po' la curiosità.

Tags: .NET Framework, ADO.NET, ASP.NET, Database, SQL Server

Continua a leggere SqLite vs Access vs Sql Ce 3.5.

Una alternativa a SkyDrive con un po' di sicurezza

2009-07-26T10:58:00+00:00

Dopo aver utilizzato per qualche tempo SkyDrive, ho deciso di cercare un'alternativa; decisione non dettata da problemi riscontrati da questo servizio, ma per semplice curiosità personale. La casualità di una ricerca in google mi ha portato a testare DropBox. Innanzitutto propone tre soluzioni, di cui solo la prima gratis, in cui offre 2GB di spazio contro i 25GB di SkyDrive. Questo limite di DropBox non mi ha creato problemi visto che non ho necessità di così grande spazio, e nel mio caso i 2GB sono più che sufficienti.

Iscrizione rapida, installato il software, e tutto fuziona senza problemi. Viene creata una directory in Documenti che si sincronizzerà con lo spazio remoto. Un dettaglio piacevole è stato quello di scoprire che funziona su Windows, Mac (di cui non me ne importa una cippa) e Linux. Io ho provato solo la versione di Windows e Linux, e su entrambi i sistemi operativi il tutto ha funzionato al primo colpo senza problemi. Il software, una volta installato, inserisce un'icona vicino all'orologio (su entrambi i sistemi operativi, su Linux ho provato solo con Gnome e appare nella taskbar superiore) dove si possono trovare le varie opzioni:

La sincronizzazione dei file con il disco virtuale remoto, avvenendo via internet, potrebbe comportare rallentamenti nella connessione, ma tra le opzioni possiamo impostare i vari limiti:

Io ho sempre lasciato l'opzione Automatic, non ho mai riscontrato problemi di velocità.Una volta modificati, inseriti o cancellati i file, è possibile vedere nell'icona animata del programma quello che sta accadendo dietro le quinte nelle varie operazioni di aggiornamento del disco virtuale remoto: anche sui singoli file nella directory interessata è presente una piccola immagine che fa capire immediatamente lo stato di aggiornamento di un file:

Non sono mai stato una persona che ha dato molta importanza alla riservatezza: in fondo scaricare su un server remoto dei propri file e come dare al gestore, chiunque esso sia, Microsoft e una qualsiasi azienda sconosciuta, la possibilità di poter guardare e controllarne il contenuto. Ovviamente le cose cambiano quando si tratta di file di lavoro o altri in cui vogliamo manterene la massima riservatezza. Una possibile soluzione che utilizzo che permette quel minimo di sicurezza è grazie a TrueCrypt. E' possibile creare una directory crittografata come file e inserendolo sullo spazio remoto, utilizzarlo come un disco virtuale, sicuri che nessuno possa leggerne il contenuto.

Per i miei scopi ho creato un disco virtuale di 250MB, e dopo un lento upload di circa due ore, ho provato a utilizzarlo con TrueCrypt per controllarne le prestazioni. Una volta modificato il contenuto di questo disco virtuale, una volta chiuso TrueCrypt, mi aspettavo l'upload di tutto il file sul server remoto con un'attesa ancora lunghissima per l'invio di tutti i 250MB, ma DropBox si è comportato in maniera egregia, inviato solo le modifiche del file in pochi secondi.

Ho testato le varie sincronizzazioni tra i vari sistemi operativi, e tutto per ora non mi ha mai dato problemi. Per ora ottimo servizio. Spero di non ricredermi.

Tags: Off Topic

Continua a leggere Una alternativa a SkyDrive con un po' di sicurezza.

Cross apply con i campi XML

2009-07-12T09:50:00+00:00

Il problema che mi si è posto: tabella con un campo xml contenente dei feed. Un esempio vale più di mille parole:

SELECT [Id],[Name],[Information] FROM [Test].[dbo].[XmlTest]

1 AZ1 <root><feed>Article1</feed><feed>Article2</feed><feed>Article3</feed></root>
2 AZ2 <root><feed>Article4</feed><feed>Article5</feed></root>
3 AZ3 <root><feed>Article6</feed><feed>Article7</feed><feed>Article8</feed></root>

Problema: con un query è possibile avere la lista dei feed contemporaneamente con un'unica query senza dover utilizzare Linq, anonymous type o miciomiciobaubau?

Sì, con questa query che utilizza il cross apply:

select [Id],[Name],s.x.query( '.' )
from [Test].[dbo].[XmlTest]
cross apply [Information].nodes('/root/feed') s( x )

Che ci permette di avere:

1 AZ1  Article1
1 AZ1  Article2
1 AZ1  Article3
2 AZ2  Article4
2 AZ2  Article5
3 AZ3  Article6
3 AZ3  Article7
3 AZ3  Article8

Comodo per unire il risultato di più record dei campi xml, no? Boh!

Tags: Database, SQL Server

Continua a leggere Cross apply con i campi XML.

Disabilitare tutti i web control in una pagina.

2009-07-08T12:21:10+00:00

Visto che mi serve spesso, ecco un po' di veloce codice:

CallAllWebControl<Button>(this.Page, action => action.Enabled = false);
CallAllWebControl<TextBox>(this.Page, action => action.Enabled = false);

public void CallAllWebControl<T>(Control controls, Action<T> method) where T:Control
{
        Action<Control, Action<T>> fun = null;
        fun = (c, MethodX) =>
             {
                 if (c.GetType()==typeof(T)) MethodX((T)c);
                 foreach (Control item in c.Controls)
                     fun(item, method);
             };
        fun(controls, method);
}

Utile anche nel caso volessi check-are tutti i checkbox nella pagina:

CallAllWebControl<CheckBox>(this.Page, action => action.Checked = true);

Non è ottimizzatissimo, ma fa bene il suo lavoro.

Tags: .NET Framework, .NET Framework 3.0, .NET Framework 3.5, .NET Framework 4.0

Continua a leggere Disabilitare tutti i web control in una pagina….