Il reportage dell'undicesima edizione del Delphi Day.

1. Marco Breveglieri
Software and Web Developer, Consultant and Trainer
Sono responsabile legale di ABLS Team, un’azienda di consulenza informatica
che si occupa di sviluppo software, realizzazione di siti Web, corsi su linguaggi di
programmazione e tecnologie correlate, installazione e configurazione di reti
aziendali, networking, Office Automation e altri servizi informatici rivolti ad
aziende e utenti finali.
Io mi occupo in modo particolare dello sviluppo di software per Microsoft
Windows e .NET Framework, della creazione e design di siti Web e
dell’organizzazione di corsi di programmazione (principalmente su Delphi e
C#/VB.NET).
 http://www.marco.breveglieri.name
Reportage
di Marco Breveglieri

2. 2

3. 3
Sommario
Introduzione ...................................................................................................................................................... 4
Giorno 1 - Conferenza ....................................................................................................................................... 4
Delphi: Stato dell’Arte (Marco Cantù – Wintech Italia)................................................................................. 4
Windows 8 (Lorenzo Barbieri – Microsoft Italia)........................................................................................... 5
Introduction to FireMonkey (Stephen Ball – Embarcadero Technologies)................................................... 7
From dbExpress to AnyDAC (Dmitry Arefiev – DA-Soft Technologies).......................................................... 8
REST Clients in Delphi (Marco Cantù – Wintech Italia) ................................................................................. 9
Dibattito: uso avanzato del linguaggio........................................................................................................ 10
Dibattito: il futuro di Windows e della VCL ................................................................................................. 10
Il Nuovo Shop Wintech Italia (Marco Cantù – Wintech Italia) .................................................................... 12
Mida – The FireMonkey revolution (Mauro Botta)..................................................................................... 12
Giorno 2 – Componenti................................................................................................................................... 14
Introduzione e apertura della giornata (Marco Cantù – Wintech Italia)..................................................... 14
Ethea: Kitto (Nando Dessena, Carlo Wolter - Ethea)................................................................................... 14
DA-Soft: Advanced AnyDAC (Dmitry Arefiev – DA-Soft Technologies) ....................................................... 15
Microsoft: Azure (Pietro Brambati – Microsoft Italia)................................................................................. 17
RemObjects: Beyond Remoting (Claudio Piffer) ......................................................................................... 19
Conclusioni ...................................................................................................................................................... 21

4. 4
Introduzione
Come ogni anno, all’inizio di giugno si rinnova l’appuntamento con il Delphi Day italiano, giunto all’undicesima
edizione, l’evento organizzato da Wintech Italia che richiama a Piacenza sviluppatori, esperti e ospiti speciali
(anche internazionali) per parlare e discutere di Delphi, di componenti di terze parti, di tecnologie e di
piattaforme che hanno a che fare con il nostro amato ambiente di sviluppo.
Alla giornata dedicata alla “conferenza classica” sono state aggiunte due giornate di approfondimento, una
riservata a corsi e seminari tecnici, l’altra dedicata ai componenti di terze parti.
Qui di seguito vi riporto tutto ciò che ho potuto annotare in merito ai contenuti ritenuti a mio parere più
interessanti o rilevanti, limitatamente alle giornate e alle sessioni che ho frequentato.
Giorno 1 - Conferenza
Delphi: Stato dell’Arte
(Marco Cantù – Wintech Italia)
Marco Cantù apre come di consueto la giornata della conferenza,
con una presenza di oltre 80 sviluppatori, illustrando l’attuale stato
dell’arte riguardo Delphi e l’universo che lo circonda.
Una prima considerazione riguarda l’evidente cambio di panorama
che gli sviluppatori si trovano davanti al giorno d’oggi: da qualche
anno si sono affermate nuove piattaforme e dispositivi e si è
assistito a una esponenziale crescita della diffusione di smartphone
e tablet, più elevata rispetto a quella dei PC tradizionali, e questo
senz’altro influirà su quelle che saranno le scelte da adottare per lo
sviluppo di software nei prossimi anni.
Nonostante Delphi sia già approdato (grazie a FireMonkey) su altre piattaforme oltre a Windows (come Mac
OSX), tutt’ora Windows rimane il target principale di Delphi, che è uno dei prodotti più utilizzati per lo sviluppo
nativo su questo sistema operativo, con alcuni ambiti dove è particolarmente diffuso (ad esempio, quello
industriale, quello fiscale e quello dell’automazione).
Tuttavia anche lo stesso Windows sta subendo dei cambiamenti:
per rispondere al mutato scenario appena descritto, Microsoft non
poteva rimanere e guardare e si è quindi messa in moto, e il
risultato di questo lavoro è Windows 8, di cui è stata rilasciata da
pochi giorni una “preview release”
(http://windows.microsoft.com/it-IT/windows-8/release-preview).
Anche Embarcadero non è rimasta a guardare: dalla primissima
versione di Delphi sino a XE, siamo stati abituati ad avere a che fare
principalmente con un solo compilatore per Windows; a partire da
Delphi XE2 i compilatori sono diventati ben 3 (e mezzo): quello per
Win32, quello per Win64, quello per Mac OSX, a cui si aggiunge
l’integrazione con Free Pascal Compiler (FPC) per raggiungere anche

5. 5
il sistema iOS e i dispositivi iPhone e iPad. Ora pare che sia in arrivo da Embarcadero anche un compilatore
specifico per processori ARM.
Lo scenario quindi traccia dei cambiamenti a cui, almeno in parte, Delphi ha già iniziato a rispondere, e le novità
in cantiere per i tool di sviluppo Embarcadero – su cui la società sta investendo particolarmente – a mio avviso
lasciano ben sperare per il futuro prossimo.
Windows 8
(Lorenzo Barbieri – Microsoft Italia)
Lorenzo Barbieri, Technical Evangelist per Microsoft Italia, ha
illustrato quali sono le novità che Microsoft introdurrà sul
mercato con il rilascio di Windows 8.
Una sessione che approfondisse i dettagli tecnici di Windows 8, anche a detta del relatore, era davvero
necessaria poiché nelle community degli utenti e soprattutto degli sviluppatori si è registrata una discreta
confusione a riguardo, per cui fare finalmente un minimo di chiarezza è fondamentale.
Vale la pena rassicurare da subito tutti gli sviluppatori Delphi: non vi saranno problemi di alcun tipo
nell’esecuzione di programmi VCL su PC equipaggiati con Windows 8. Il nuovo sistema operativo mantiene la
piena compatibilità con la quasi totalità degli applicativi Win32 (e Win64) che girano attualmente su Windows 7;
si escludono solo alcuni casi particolari, quali driver e altri programmi che hanno un rapporto molto stretto con il
sistema operativo stesso.
Windows 8 sarà installato anche su tablet, basati su processori Intel oppure su ARM. Potenzialmente, le
applicazioni VCL potranno girare anche su tutti i tablet che saranno equipaggiati con Windows 8, purché questi
montino un processore Intel (dato che Delphi non dispone di un compilatore ARM, per adesso).
Riassumendo in breve, una architettura Intel (PC o tablet) con Windows 8 potrà eseguire tutte le cosiddette
“desktop application”, cioè tutte le applicazioni che si basano sulla Windows API classica, incluso Office, tutte le
applicazioni “legacy” (che nella terminologia Microsoft sembra riferirsi già a qualsiasi programma “non Metro”).
A proposito di Metro, quali sono le caratteristiche di questa nuova architettura? Le applicazioni Metro sono file
eseguibili con un nuovo formato, differente da quello tradizionale Win32 o .NET (da cui prendono solamente la
struttura dei metadati che ne descrive il contenuto) che girano in modalità “sandboxed” e si basano sulla nuova
API detta WinRT (Windows Runtime), che incapsula le API di più basso livello di Windows 8 in forma “object
oriented” e indipendente dal dispositivo hardware.
WinRT è un API nativa (non managed, come nel caso di .NET), che supporta più processori (ARM e Intel) ed è
ottimizzata per il risparmio della batteria. Si tratta dell’unica API accessibile dalle applicazioni Metro, poiché
l’accesso alle API Win32 è precluso (salvo casi particolari), essendo quest’ultima legata a uno specifico
processore, quindi tale strada sarebbe non “portabile” e snaturerebbe l’applicazione Metro stessa.
L’interfaccia utente delle applicazioni Metro sono basate su XAML, lo stesso formato XML-based impiegato in
WPF (Windows Presentation Framework), sebbene questa volta venga gestito da un’architettura nativa (che
sfrutta direttamente DirectX) e non managed come .NET.
Ad eccezione dei sistemi operativi per tablet più conosciuti, Windows 8 consente l’esecuzione “side by side”
sullo schermo di due applicazioni (una principale e una laterale).

6. 6
WinRT include tutte le categorie di classi comunemente richieste per la creazione di applicazioni: threading,
security, media, data & communication, oltre ai tipi fondamentali. Supporta inoltre le tecnologie più recenti,
come la geolocalizzazione e le ultime interfacce di comunicazione (come NFC, Near Field Communication).
Ma come si scrivono le applicazioni Metro? Microsoft ha creato le cosiddette Projections, interfacce che
espongono i contenuti delle DLL di WinRT in una forma adattata al linguaggio o all’ambiente di programmazione
preso come riferimento (ad esempio, adottando un formato “PascalCase” per i membri nei linguaggi C# e
VB.NET). Le Projections sono risorse pubbliche e documentate. Il formato dei metadata che descrivono i
contenuti delle librerie è lo stesso adottato per .NET (in quanto già standardizzato e conosciuto agli sviluppatori).
E’ possibile creare applicazioni Metro principalmente con C#, Visual Basic .NET, C++ e HTML + JavaScript + CSS3.
L’API WinRT semplifica e favorisce l’esecuzione di operazioni asincrone. Per la costruzione dell’interfaccia
grafica, invece, Microsoft suggerisce l’adozione di Expression Blend, il tool appositamente progettato per le
esigenze di design dell’interfaccia utente, affiancato a Visual Studio per la programmazione vera e propria (nelle
SKU di rango più alto sono previsti anche strumenti per il test automatizzato delle interfacce utente).
Come si presenta il nuovo sistema operativo Windows 8? Dal
punto di vista dell’interfaccia, tutto è stato ridotto
all’essenziale, con un design davvero minimale. Una volta
eseguito il login, viene mostrato il nuovo “menu Start”, formato
da un pannello scorrevole (navigabile con comodo sui tablet,
ma anche sul desktop con la rotellina del mouse) che costituisce
il browser delle applicazioni e mostra i programmi installati. Tra
i programmi spunta anche il desktop tradizionale, che appare
del tutto simile a quello odierno di Windows 7 una volta
lanciato, ma privo del classico pulsante “Start” (facendo clic con
il tasto destro nella zona in cui si trova abitualmente “Start” è possibile mostrare comunque una serie di shortcut
personalizzabili). E’ stato semplificato l’effetto Aero e la trasparenza delle finestre, che risultano più squadrate;
infine in Windows Explorer è stato inserito il Ribbon che organizza in modo congeniale le operazioni per gestire
dischi, cartelle e file.
Nella pratica, a detta di Microsoft, l’interfaccia utente di Windows 8 è stata riprogettata per adattarsi
perfettamente sia al PC tradizionale che ai tablet, portando la lunga esperienza maturata da Microsoft sui
sistemi operativi per PC desktop nel mondo dei dispositivi tablet.
L’efficacia di queste scelte sarà senz’altro motivo di accesi dibattiti quando Windows 8 verrà definitivamente
rilasciato e il sistema verrà messo alla prova degli utenti finali.
Lorenzo Barbieri ha mostrato poi il sistema operativo in esecuzione su un tablet Intel. Windows 8 supporta in
modo specifico diverse tipologie di penne (capacitivo e resistivo), sfruttando la loro differente precisione, oltre
al classico e naturale dito della mano, che sono distintamente riconoscibili anche dai programmi (ad esempio,
Paint regola lo spessore del tratto in base alla dispositivo di puntamento con cui si tocca lo schermo).
All’interno di Windows 8 troveremo inoltre il nuovo marketplace di Microsoft: Windows Store. Dal market sarà
possibile acquistare, scaricare e installare direttamente applicazioni Metro, accedendo sia da PC sia da dispositivi
mobile. I produttori potranno anche inserire applicazioni non-Metro sullo store, ma per queste tuttavia è
possibile solo pubblicare un collegamento al proprio sito per il download. Le applicazioni Metro possono essere
“certificate” per lo store utilizzando un apposito tool.
L’intenzione di Microsoft, stando alle dichiarazioni fatte, sarebbe quella spingere il market per promuovere la
distribuzione di applicazioni e sostenere così la propria fonte principale di guadagno: il sistema operativo. Oltre

7. 7
alla distribuzione, Windows Store fornisce inoltre strumenti per la pubblicità (tramite Microsoft Advertising), la
gestione delle licenze oltre a statistiche assortite.
Al termine della presentazione, Lorenzo Barbieri ha invitato i “pionieri” interessati a pubblicare in anteprima
programmi Metro per Windows 8 a inviare una e-mail all’indirizzo mitamsdn@microsoft.com per sottoporre la
propria applicazione alle operazioni di pre-certificazione e accesso gratuito (per un periodo di tempo limitato)
alla piattaforma Windows Store e ai servizi che offre.
Introduction to FireMonkey
(Stephen Ball – Embarcadero Technologies)
Nella sessione successiva, Stephen Ball (Technical Sales Consultant, Embarcadero) ha
presentato le caratteristiche principali di FireMonkey a tutti coloro che ancora non
conoscevano questa libreria, rilasciata in Delphi XE2, fornendo anche alcuni dettagli
sulle direzioni future che Embarcadero intende intraprendere a riguardo.
In breve sintesi, FireMonkey è una libreria che disegna interamente l’interfaccia
utente (a differenza della VCL, che si rifà alle API di Windows, a 32 e 64 bit). La libreria
sfrutta la GPU della scheda grafica per riprodurre effetti e animazioni, lasciando libera la CPU per la logica
applicativa vera e propria (per usare le parole di Stephen Ball, «FireMonkey brings business alive»).
La gerarchia dei controlli visuali è semplificata rispetto
alla VCL, con due soli tipi di controlli: primitivi e
“stilizzati”; lo stile è ciò che in FireMonkey definisce le
primitive che concorrono al tracciamento di un controllo
(ad esempio, un pulsante), grazie alla gestione
particolare del “parenting” (diversa dalla VCL) dove
qualsiasi controllo può contenerne altri, a cui si
applicano gli stessi effetti di rotazione, posizionamento
e dimensionamento del relativo contenitore.
E’ possibile scaricare un diagramma completo della
gerarchia delle classi dalla pagina ufficiale dedicata alla
libreria FireMonkey (http://www.embarcadero-
info.com/firemonkey/firemonkey_chart_poster.pdf).
Si noterà che non sono presenti controlli “data aware”, poiché la connessione ai dati avviene tramite la
tecnologia LiveBindings (per usare le parole di Stephen, «LiveBindings connects anything to anything»),
introdotta sempre in XE2.
Per una illustrazione più approfondita della libreria FireMonkey e di LiveBindings, rimando alla lettura del
reportage di “RAD Studio XE2 World Tour” (http://www.marco.breveglieri.name/blog/?p=27).
FireMonkey è una libreria che riceve frequenti e regolari aggiornamenti (anche tramite “hot fix”) per un
continuo apporto di migliorie e correzioni di bug.
Con particolare riferimento alle piattaforme mobile, l’intenzione è quella di espandere la gamma dei dispositivi
supportati dalla libreria e astrarre sempre più le loro caratteristiche (localizzazione, fotocamera, accelerometro,
ecc.).

8. 8
Grazie alla suddivisione in corso dei compilatori in due parti, un backend e un frontend, Embarcadero pianifica di
introdurre il supporto a nuove piattaforme hardware (es. ARM) e software (es. Android e Metro). FireMonkey è
una libreria nata appositamente per supportare più piattaforme, pertanto giocherà senz’altro un ruolo
fondamentale in questo frangente.
La presentazione si è conclusa con una breve sessione di domande e risposte, di cui riporto qui di seguito quelle
a mio avviso più interessanti, ovviamente con le risposte fornite da Stephen Ball.
 Q) Ha senso oggi iniziare a sviluppare un’applicazione con la libreria FireMonkey?
R) Dipende. Se si ha la certezza di non doversi muovere a breve termine su altre piattaforme con la
propria applicazione, o se vi è una forte dipendenza da componenti di terze parti di cui non esiste una
versione crossplatform per FireMonkey, la VCL continuerà a essere supportata ancora molto a lungo e
rappresenta una soluzione robusta, collaudata e matura; se invece si vuole compilare la propria
applicazione su altre piattaforme, FireMonkey è progettata appositamente per questo scopo.
 Q) Quanto sforzo sta impiegando Embarcadero nello sviluppo della VCL rispetto a FireMonkey?
R) Embarcadero investe ancora molto nella VCL, tant’è vero che la XE2 ha visto l’introduzione dei nuovi
“VCL Styles”, delle integrazioni a DataSnap e del motore LiveBindings, tutti elementi che possono essere
utilizzati anche nelle applicazioni VCL, e non solo in FireMonkey.
From dbExpress to AnyDAC
(Dmitry Arefiev – DA-Soft Technologies)
Dmitry Arefiev, CEO di DA-Soft Technologies, ha presentato la suite AnyDAC e i vantaggi nell’uso dei suoi
componenti al posto di quelli forniti dalle tradizionali librerie dbExpress o dbGo for ADO (oltre all’obsoleto e
vetusto BDE, ovviamente) o da (altre) terze parti.
La libreria dbExpress è la soluzione “out of the box” per l’accesso a database SQL Server: essa include una API
compatta, è crossplatform, è veloce, è flessibile (grazie all’uso in combinazione con il
ClientDataSet, un componente ricco di funzionalità). Tuttavia, presenta diversi
svantaggi: il supporto ai DBMS, in particolare a loro specifiche versioni e
caratteristiche, è limitato; inoltre, talvolta risulta poco stabile; il componente
ClientDataSet – sebbene potente – è tendenzialmente lento; infine, la migrazione da
BDE a dbExpress è una procedura difficoltosa (dovuta alla differenza tra i componenti
delle due librerie e al loro principio generale di funzionamento).
AnyDAC si pone sul mercato con il tentativo di superare questi limiti per soddisfare le esigenze delle moderne
applicazioni DB-based, fornendo
 il supporto a una ampia gamma di database e di loro particolari versioni;
 una API unificata per accedere alle caratteristiche dei database, anche a quelle specifiche, ma con una
interfaccia standard;
 il supporto al crossplatform (è disponibile anche su Linux e Mac);
 un set di componenti e driver estremamente veloci;
 aggiornamenti regolari e documentazione;
 l’accesso ai sorgenti della libreria;
 una procedura agevolata e ben documentata per la migrazione dal BDE.
Ovviamente, AnyDAC presenta anche alcuni svantaggi:
 la struttura dei driver è complessa (se deve essere scritta o modificata da terze parti);
 AnyDAC non è gratuito. 

9. 9
Ma quali sono i requisiti delle moderne applicazioni DB per cui AnyDAC rappresenta la scelta ideale?
Innanzitutto, ogni client dovrebbe supportare (senza porre problemi) versioni vecchie e nuove di uno specifico
formato di database; sarà capitato a chiunque di riscontrare errori come «Driver could not be properly
initialized» (dbExpress), oppure «Driver not found» (ADO), e spesso in questi casi non si ha un’idea precisa di
come procedere per risolvere il problema; AnyDAC fornisce invece un report dettagliato nel tentativo di
effettuare la connessione, consentendo di diagnosticare meglio eventuali problemi e soprattutto sapere dove
intervenire in caso di errore.
A proposito di errori, alcune delle librerie di uso più comune non restituiscono codici identificabili quando si
verifica un problema di qualunque tipo, oppure questi variano da database a database; AnyDAC fornisce invece
una serie di eccezioni che identificano in modo uniforme gli errori e sono indipendenti dal database in uso.
AnyDAC supporta inoltre le transazioni, sia multiple che nidificate, per tutti i database supportati e gestisce
problemi di networking in modo elegante e sicuro (attivando la modalità “offline” e implementando “retry”
automatici).
Infine, AnyDAC semplifica il mapping dei tipi di dati tra il DB e l’applicazione e supporta l’esecuzione di script
SQL con diversi dialetti, funzioni incorporate, direttive di pre-processing e riconoscimento intelligente dei
marcatori dei parametri, a cui si aggiungono logiche per l’aggiornamento massivo di dati (disabilitando le
“business rule” e gestendo array di istruzioni DML).
Un approfondimento della suite AnyDAC, con dettagli tecnici e demo, verrà fatta nella giornata dedicata ai
componenti di terze parti (si veda più avanti).
REST Clients in Delphi
(Marco Cantù – Wintech Italia)
Nel successivo talk, Marco Cantù ha mostrato alcuni esempi di
client REST realizzati con Delphi.
Per chiarezza, è indispensabile fornire innanzitutto la definizione
di REST (Representational State Transfer): con questo termine ci si
riferisce alla modalità di invocazione di procedure remote
tramite chiamate HTTP, passando i parametri direttamente
nell’URL (tipicamente nel caso di un operazione di GET) oppure
tramite POST, inviando un pacchetto di dati in formato XML o
JSON (http://json.org); a fronte della chiamata, si riceve dal
server una risposta genericamente nello stesso formato, XML o
JSON.
Si tratta di un protocollo che associa a ciascun
servizio/operazione un URL univoco e che risulta spesso più
semplice e malleabile rispetto ai classici Web Service basati sul
più rigido protocollo SOAP.
Per poter realizzare un client REST, cioè un applicazione che possa invocare tali servizi, è sufficiente utilizzare un
linguaggio, una libreria o un framework che sia in grado di effettuare una chiamata HTTP; in Delphi ciò è
possibile grazie al componente TIdHTTP (parte di Indy Components e incluso in Delphi), oppure utilizzando una
delle tante librerie gratuite in circolazione (ad esempio, ICS – Internet Component Suite,
http://www.overbyte.be/eng/products/ics.html).

10. 10
Delphi offre nativamente il supporto al formato JSON attraverso un insieme di classi che si trovano nella unit
DBXJSON (http://docwiki.embarcadero.com/Libraries/en/Data.DBXJSON).
Attraverso alcuni demo si è data ampia dimostrazione delle potenzialità di questo strumento ormai largamente
diffuso e supportato da qualsiasi applicazione o servizio Web che disponga di una Web API; particolarmente
significativo il demo del datasheet condiviso su Google Docs, modificato
dall’applicazione Delphi con cambiamenti visibili in tempo reale dalla pagina Web
del servizio.
Non è mancato un cenno al supporto cloud presente in Delphi XE2, riprogettato
come Cloud API e basato su interfacce comuni che consentono la creazione di
classi concrete per accedere ai servizi di storage e queue di Amazon EC2 e
Windows Azure (di quest’ultimo Pietro Brambati ne parlerà in modo approfondito
nel giorno seguente).
Dibattito: uso avanzato del linguaggio
E’ seguita una sessione formata da due dibattiti in parallelo, uno dedicato a multitier e remoting e uno sull’uso
avanzato del linguaggio, che è quello a cui ho partecipato.
Marco Cantù, moderatore del dibattito, ha sottolineato come l’evolversi delle caratteristiche del linguaggio
Delphi, specialmente nelle ultime versioni (con la RTTI avanzata, l’avvento degli attributi, l’introduzione dei
Generics e il supporto ai metodi anonimi, solo per citarne alcune), abbia di fatto invogliato parecchi sviluppatori
a scrivere nuove librerie (ad esempio, framework di Dependency Injection, ORM, Collections potenziate o tool
per Unit Testing) portando quindi nell’ambiente Delphi nuovi strumenti e architetture a cui gli sviluppatori che
utilizzano altri linguaggi e piattaforme (ad esempio, .NET e Java) sono già abituati da tempo.
Si è discusso in modo molto disteso e rilassato delle avventure (o disavventure) dei presenti in merito
all’organizzazione di propri progetti, o a quella di progetti “ereditati”, e alla difficoltà di trovare il giusto
equilibrio nell’adottare una architettura che può essere molto semplice, a volte forse troppo, comparata con
l’uso e lo sfruttamento di tutti gli strumenti “moderni” e pattern tipici delle soluzioni più complesse, impiegate
anche per progetti “piccoli ma che potrebbero crescere”. Quale dei due approcci è il migliore? Che la verità stia
nel mezzo? Se sperate di trovare in questo testo una risposta definitiva a questo annoso problema, mi spiace
deludervi. 
Dibattito: il futuro di Windows e della VCL
A seguire un’altra coppia di dibattiti, il primo sul futuro del sistema operativo Windows (al momento target
principale di Delphi) e della libreria VCL, il secondo su componenti e librerie suggerite dai presenti in base alle
proprie esperienze. Ho deciso di seguire il primo argomento anche perché su componenti e librerie si sarebbe
discusso più che abbondantemente il giorno successivo.
Il dibattito è stata un’occasione per esprimere le proprie opinioni a caldo sull’imminente Windows 8 e su
quanto visto nella presentazione del mattino, concentrandosi al massimo sugli aspetti e gli elementi che più
interessano da vicino i programmatori Delphi da un punto di vista pragmatico.
Innanzitutto, in Windows 8 ritroviamo sostanzialmente tutto ciò che è presente in Windows 7: il pulsante
“Start” se n’è andato, tuttavia il Desktop tradizionale presenta tutte le caratteristiche della versione precedente,
mantenendo ad esempio le anteprime delle finestre delle applicazioni, la colorazione stile “progress bar” nei
pulsanti della task bar, in pratica supportando tutte quelle che sono le API specifiche introdotte in Windows 7.

11. 11
Una novità che si nota da subito è l’introduzione del “Ribbon” all’interno di Windows Explorer (il classico
Gestione Risorse), anche se questo non stravolgerà probabilmente la vita a molte persone.
Il numero di release del nuovo sistema operativo è 6.2; se si pensa che Windows 7 reca il numero 6.1, si intuisce
che il kernel del nuovo Windows 8 costituisce una “minor release” senza particolari novità tecniche (se si esclude
l’introduzione di Metro).
Ora che finalmente si è raggiunta la maturità dal punto di vista delle performance offerte dalle schede grafiche in
dotazione a PC e tablet, è buffo che in Windows 8 sia stato ridimensionato Aero e il corrispettivo “effetto vetro”
(glass), probabilmente per ridurre il consumo di batteria sui dispositivi mobili, pertanto le finestre che prima
sfruttavano questo effetto traslucido ora appariranno più opache.
Le applicazioni Delphi realizzate con la VCL saranno pienamente compatibili con il nuovo sistema operativo. Lo
sviluppo su Metro con tool Embarcadero al momento è possibile solo con Delphi Prism (Oxygene). La libreria
VCL, basandosi sulle API Win32/64 di Windows, non consente ovviamente di creare programmi per Metro.
Sulla nuova piattaforma Metro nello specifico, per coloro che volessero iniziare a svilupparci applicazioni,
occorre tenere presente quali sono le limitazioni pratiche per quei programmi che girano all’interno
dell’ambiente “sandboxed”: ad esempio, non è possibile fare accesso diretto al file system e l’applicazione deve
provvedere a salvare il proprio stato e a ripristinarlo tale e quale poiché, causa inutilizzo, il sistema potrebbe
terminarlo dopo qualche minuto.
Per quanto riguarda il marketplace Windows Store, questo può suscitare senz’altro interesse per gli ISV, ma è
lecito aspettarsi che la sua penetrazione sarà maggiore nel settore “consumer”, dove presenta maggiori
vantaggi e più appetibilità (si pensi al mercato dei videogiochi), mentre avrà probabilmente meno incidenza
nell’area “business”. A questo proposito, vale la pena ricordare che la stessa Embarcadero produce e
distribuisce già oggi uno store Win32, AppWave (http://www.embarcadero.com/products/appwave), con tante
applicazioni gratuite e utilizzabile anche da coloro che desiderano distribuire le proprie applicazioni enterprise e
gestirne le licenze.
Anche l’esecuzione di sole due applicazioni in primo piano costituisce solamente un piccolo passo per un
sistema operativo che si dice “riprogettato partendo dal desktop”, e pare una soluzione addirittura molto
limitante se si considera che alcune delle macchine su cui girerà Windows 8 saranno dotate di processore quad
core che non verranno sfruttati a dovere.
C’è stata inoltre una parziale disinformazione in
merito alla preview rilasciata in questi giorni: molti
di coloro che hanno installato il sistema per
testarlo successivamente hanno anche tentato di
disinstallarlo, tant’è vero che cercando “Windows
8” su Google curiosamente una delle voci suggerita
più frequentemente è “windows 8 uninstall”. Purtroppo però, non è possibile disinstallare Windows 8 senza
reinstallare completamente il sistema precedente, quindi meglio eseguirlo in dual boot o all’interno di una
macchina virtuale (es. Virtual Box, https://www.virtualbox.org) per coloro che vogliono metterlo alla prova.
Dal sondaggio recentemente pubblicato da Embarcadero per “tastare il polso” alla propria community in merito
alle direzioni da privilegiare riguardo il futuro di Delphi, pare che alla domanda sulle tempistiche previste per
l’adozione di Windows 8 come target delle proprie applicazioni la maggioranza abbia risposto “Tra più di un
anno” (anche se sarebbe curioso verificare nuovamente questa tendenza quando Windows 8 sarà disponibile
sugli scaffali dei negozi o preinstallato all’interno di nuovi PC e tablet).

12. 12
La sessione si è conclusa con una boutade provocatoria di Marco Cantù: il lancio di una applicazione VCL con
sfondo colorato a tinta unita, massimizzata a pieno schermo, con un paio di “SpeedButton” e font grandi… ecco
pronta in pochi istanti una applicazione Metro. 
Il Nuovo Shop Wintech Italia
(Marco Cantù – Wintech Italia)
Marco Cantù ha presentato come “case study” il nuovo shop online di Wintech Italia (http://shop.wintech-
italia.com), attraverso il quale la società
rivende i prodotti Embarcadero, oltre a
componenti e librerie di terze parti.
consulenze e corsi.
Il nuovo e-shop è stato realizzato con
Delphi XE2 ed è basato sulla tecnologia
DataSnap, appoggiandosi al framework
realizzato dallo stesso Cantù Delphi Relax
(http://code.marcocantu.com/p/delphirel
ax); per i dati si utilizza un database
FireBird (a cui il framework accede usando pattern come ActiveRecord e TableMapper); le funzionalità
dinamiche della pagina lato client sono basate su JQuery (http://jquery.com), il noto framework che semplifica
la manipolazione del DOM cross-browser in JavaScript, di cui una parte viene generata dinamicamente dallo
stesso Delphi Relax (ad esempio, la logica di validazione lato client) tramite attributi applicati alle classi,
sfruttando le potenzialità della RTTI estesa di Delphi.
Mida – The FireMonkey revolution
(Mauro Botta)
A conclusione della giornata di conferenza, Mauro Botta
ha presentato Mida, un tool per la conversione di progetti
VCL in FireMonkey, con supporto sia per Delphi che per
C++Builder (http://www.midaconverter.com).
Come abbiamo già detto, la libreria FireMonkey per lo
sviluppo crossplatform presenta molteplici differenze
rispetto alla tradizionale VCL, non solo dal punto di vista
della sua architettura interna. Molti dei componenti della
libreria FireMonkey (abbreviata in FMX) possono essere
assimilati – in termini di caratteristiche e modalità di
utilizzo – ai corrispettivi “cugini” della libreria VCL, tuttavia
ci sono parecchie differenze che richiedono necessariamente una modifica al codice del progetto VCL che
vogliamo eventualmente migrare su FMX: ad esempio, le posizioni sono espresse da proprietà aventi nomi
differenti (Left e Top nella VCL, Position in FMX) e tipo differente (sono interi nella VCL, e a virgola mobile in
FMX); vi sono poi alcuni controlli VCL che sono assenti in FMX (generalmente perché in FMX si possono ottenere
risultati equivalenti, e anche superiori, combinando tra loro i controlli di base esistenti, sfruttando la potenzialità
del “parenting” gestito da FireMonkey), per non parlare dell’accesso ai dati, ove sappiamo che FMX è del tutto
priva dei cosiddetti “data controls”, ma sfrutta la nuova tecnologia LiveBindings per rendere virtualmente
qualsiasi controllo, anzi qualsiasi oggetto, collegabile a un’origine dati o a qualunque altro oggetto.

13. 13
Mida è il tool che consente – in modo configurabile e personalizzabile – di eseguire
questo tipo di lavoro, cioè applicare tutte le modifiche puntuali necessarie al progetto
VCL affinché possa essere compilato su FireMonkey.
Il tool affronta inoltre alcune problematiche addizionali, che sarebbero discretamente
tediose da gestire manualmente; ad esempio, Mida converte le immagini nel formato
PNG, mantenendo la trasparenza ove possibile, e provvede a creare stili quando
necessario per mantenere i colori dei pannelli e delle etichette utilizzate nell’interfaccia
visuale VCL (solo quando necessario, lavorando quindi in modo intelligente con spreco minimo di risorse).
Dulcis in fundo, Mida riesce a convertire anche un discreto numero di componenti di terze parti, ad esempio i
componenti realizzati da TMS Software.
Per eseguire il proprio compito, il tool provvede a scaricare specifiche tabelle di conversione da un server,
mantenute costantemente aggiornate dal produttore.
Oltre ai componenti, ai controlli e alle loro proprietà, il tool si occupa anche di ritoccare il codice sorgente,
sostituendo quelle istruzioni note per funzionare solo nel contesto della VCL e in ambiente esclusivamente
Windows (ad esempio, la visualizzazione di MessageBox attraverso l’oggetto Application); il codice viene
corretto con l’introduzione di funzioni “wrapper” nel codice del progetto, fornite da librerie di supporto alla
migrazione che fanno parte del tool Mida e che reindirizzano le chiamate affinché utilizzino approcci validi in
ambito crossplatform. Oltre al codice, anche le unit elencate nella clausola uses vengono ritoccate (dove
possibile).
Tutte le azioni che Mida può
eseguire nel corso della
conversione sono configurabili; al
termine del processo, il tool
presenta anche un log delle
modifiche effettuate (o
dell’impossibilità di applicarle),
fornendo quindi un valido aiuto
anche nell’individuazione dei punti
critici in cui è necessario
intervenire manualmente per
rendere il progetto VCL migrabile a
FireMonkey e alleviando così il
processo di conversione.

14. 14
Giorno 2 – Componenti
Introduzione e apertura della giornata
(Marco Cantù – Wintech Italia)
Alla tradizionale conferenza, è stata aggiunta una ulteriore giornata allo scopo di approfondire i principali
componenti e librerie di terze parti disponibili.
Si tratta di un mercato che negli ultimi anni ha rivestito un ruolo primario per Embarcadero, che ha sempre
incluso prodotti di terze parti selezionati in Delphi e C++Builder, mentre ha provveduto ad acquisirne altri
assieme alle società che se ne occupavano (come nel caso di KSDev, società che produceva VGScene, da cui è
nata poi la libreria FireMonkey).
Ethea: Kitto
(Nando Dessena, Carlo Wolter - Ethea)
Nando Dessena, affiancato da Carlo Wolter, hanno illustrato le
funzionalità di “Kitto”, un framework nato per creare applicazioni Web
lato server con Delphi. Il progetto è Open Source e si può scaricare con
un client GIT da Google Code (http://code.google.com/p/kitto).
Kitto consente di creare applicazioni di tipo RIA (Rich Internet Application) basate su AJAX, appoggiandosi lato
client al framework ExtJS (http://www.sencha.com/products/extjs) tramite il package ExtPascal
(http://code.google.com/p/extpascal), a cui sono stati apportati alcuni
aggiustamenti.
Kitto è un tool “database agnostic”: può appoggiarsi attualmente a
dbExpress o ad ADO, ma è virtualmente possibile integrare il supporto
a qualsiasi tipo di storage.
L’applicazione tipica Kitto si basa su un set di file YAML
(http://www.yaml.org): si tratta di file di testo, particolarmente
leggibili e la cui struttura logica è data dall’indentazione delle righe.
Questo formato è stato scelto poiché ritenuto altrettanto espressivo
rispetto ai più diffusi XML e JSON, ma più asciutto e sintetico.
Il motore del framework è Open Source, mentre Ethea fornisce tool
aggiuntivi e supporto tecnico a pagamento.
Kitto sfrutta l’interfaccia FastCGI di Apache lato server per generare pagine HTML e JavaScript sul client.
L’applicazione server è un programma Delphi che contiene il motore di Kitto (quello che interpreta e utilizza i file
YAML) e la “business logic”, facilmente integrabile dallo sviluppatore, fungendo da “application server”. La scelta
di utilizzare Apache è dovuta alla robustezza, affidabilità e scalabilità fornita da questo noto e diffuso web
server.
Kitto utilizza un paradigma del tutto simile a MVC, con alcune semplificazioni. E’ possibile estendere facilmente
classi specifiche del framework per aggiungere nuove regole di business (ad esempio, nuove validazioni
“custom” dei valori inseriti dall’utente). Del progetto fanno parte i file “.yaml” che definiscono la configurazione
generale, i modelli del dominio, le viste (cioè la definizione della struttura delle pagine che costituiscono
l’interfaccia utente), risorse di vario tipo e file esterni (fogli di stile, immagini, ecc.).

15. 15
Le applicazioni supportano il “multilingua” grazie all’uso di Gettext (http://it.wikipedia.org/wiki/Gettext).
Per mostrare le funzionalità basilari di Kitto, Nando Dessena ha avviato il tool KIDE, un IDE sviluppato
appositamente per modificare i file YAML e gestire tramite wizard e procedure guidate le operazioni più tediose,
ad esempio la generazione automatica di un modello a partire da un database e la creazione di viste pronte
all’uso o alla personalizzazione. KIDE aiuta inoltre a individuare errori di sintassi nei file YAML.
Il primo passo per la creazione di un’applicazione Kitto consiste nella definizione del file di configurazione e
avvio dell’applicazione: il file “Config.yaml”. Esso contiene le impostazioni principali, quali il titolo
dell’applicazione, la configurazione dei database, i parametri di autenticazione, parametri specifici per ExtJS e
altre impostazioni globali.
Kitto adotta un approccio “Convention over Configuration”, molto simile a quello adottato da altri framework
molto noti (come Ruby On Rails, ad esempio), dove la configurazione del software ricalca impostazioni
genericamente valide per la maggior parte degli sviluppatori, seguendo una convenzione che può essere alterata
solo nei punti che si intende effettivamente personalizzare rispetto al comportamento predefinito,
semplificando così il proprio lavoro e velocizzando la stesura del progetto.
I file YAML delle viste contengono la dichiarazione di un controllo visuale di primo livello (Window, che
riproduce una finestra, o ViewPort, che fornisce un’area in grado di occupare l’intera pagina); all’interno del
controllo possono essere annidati diversi “layout panel” per stabilire la collocazione dei controlli figli e la
struttura generale dell’interfaccia utente. Attraverso questi file YAML, il motore di Kitto è in grado di generare
dinamicamente le viste, con la possibilità di includere filtri, ordinamenti e raggruppamenti dei dati.
L’architettura di Kitto è estensibile: si possono aggiungere nuovi Controller, nuove regole di business, nuove
macro da utilizzare nei file YAML e altro ancora.
Per una introduzione all’architettura di Kitto, il download del codice sorgente e le informazioni preliminari per
creare la prima applicazione rimando al Wiki ufficiale del progetto (http://code.google.com/p/kitto/wiki). Sono
disponibili anche dei demo online già pronti per vedere quali sono le potenzialità del framework
(http://kitto.ethea.it).
DA-Soft: Advanced AnyDAC
(Dmitry Arefiev – DA-Soft Technologies)
Dmitry Arefiev ha illustrato le potenzialità della suite di componenti AnyDAC.
Innanzitutto, ha dato qualche ragguaglio sulla sua società che distribuisce il prodotto, DA-Soft Technologies, di
cui è CEO e fondatore: l’azienda privata è nata nel 1999 e si è specializzata fin da subito in tecnologie per
l’accesso veloce ai dati.
Successivamente, ha introdotto quelle che sono le caratteristiche peculiari di AnyDAC:
 architettura particolarmente stabile e veloce;
 percorso di migrazione semplificato e guidato dal BDE;
 unificazione in un solo framework dell’accesso a diversi tipi di database;
 compatibilità con più piattaforme (è disponibile per VCL, LCL e FireMonkey);
 fornitura di un supporto tecnico di qualità;
 distribuzione dei sorgenti (ove possibile).

16. 16
La libreria AnyDAC ha attraversato diverse “milestone”: inizialmente rilasciata nel 2003 con il nome “DENT”,
includeva il supporto a MySQL e Oracle; poi è stata rilasciata gratuitamente sotto il nome di “FreeDAC” (versione
1.0) nel 2005 per diventare infine un prodotto commerciale nel 2008 con il rilascio di AnyDAC (versione 2.0).
AnyDAC è composto dai seguenti elementi principali:
 Core components: si tratta dei
componenti principali per
l’accesso ai dati utilizzabili
all’interno dell’applicazione
Delphi (ADConnection,
ADTransaction, ADQuery,
ADStoredProc, …);
 GUI components: si tratta di
componenti che consentono di
personalizzare l’interfaccia
dell’applicazione e di alcune
finestre di dialogo fornite da
AnyDAC (ad esempio, la dialog
di login, la finestra di attesa per
l’esecuzione di operazioni asincrone, cursori di wait, ecc.);
 Native drivers: è la parte che comprende tutti i driver nativi che consentono di collegarsi a qualsiasi tipo
di database supportato da AnyDAC (tra cui Oracle, SQL Server, IBM DB2, FireBird, MySQL, PostgreSQL,
Sybase SQL Anywhere, InterBase, Advantage Database, SQL Azure, SQLite, Access, e altri ancora);
 Service components: componenti addizionali che permettono l’accesso a specifici servizi della libreria e
dei database supportati.
AnyDAC supporta una discreta varietà di tool e piattaforme: Delphi e C++Builder (con VCL per Windows e
FireMonkey per Windows e Mac), Lazarus e Free Pascal Compiler; inoltre, con specifico riferimento a RAD
Studio, AnyDAC supporta un’ampia gamma di versioni di Delphi: a partire dalla 5 sino ad arrivare a XE2!
In riferimento alla migrazione dal BDE, AnyDAC rappresenta un valido strumento per questo lavoro grazie a una
buona compatibilità con i componenti della vetusta libreria (dichiarata obsoleta da tempo, più di 10 anni!),
oltre a fornire una procedura guidata, semi-automatica e ben documentata per gestire il traumatico passaggio.
Tra le caratteristiche principali di AnyDAC, cito inoltre
 il report di informazioni completo generato quando si verificano problemi di connessione (consentendo
di rispondere facilmente alla domanda «What to do next?» quando non è possibile connettersi a un
database);
 il trace e il monitoring completo dell’applicazione quando vengono effettuate delle interrogazioni di
qualsiasi tipo con la base dati collegata;
 le definizioni dei parametri di connessione, che possono essere salvate in un file esterno (simile
all’approccio ,BDE o ai file UDL presenti in ADO), o in un file INI, o in qualsiasi altra locazione;
 più di 60 opzioni differenti per configurare qualsiasi dettaglio del motore (il fetching dei dati,
l’aggiornamento, la formattazione, la persistenza, il locking, i valori di default per le connessioni e altro
ancora);
 il meccanismo di data type mapping, che consente di effettuare trasformazioni e conversioni dei valori
dai tipi di dati definiti nel database, o nei database supportati, nei corrispondenti tipi nativi Delphi
desiderati, astraendo quindi il più possibile la struttura fisica delle tabelle;
 il supporto al rowset fetching, che consente di ottenere un numero variabile di record configurabile per
ogni “roundtrip” effettuato sul server SQL, così da regolare le prestazioni e il traffico di rete in modo
granulare;

17. 17
 il supporto al batch fetching, che permette di inviare più statement SQL contemporaneamente al
database server e ottenere i relativi “result set”, ispezionabili uno per uno;
 il supporto di Array DML: consiste nella possibilità di poter eseguire INSERT, UPDATE e DELETE in modo
massivo, minimizzando il traffico di rete e il workload del server (con alcuni database – ad esempio,
Oracle – l’incremento delle performance è di 5 a 1 su 10.000 record);
 la capacità di eseguire operazioni asincrone, con la possibilità di annullare l’operazione in corso
(eventualmente sfruttando una finestra di dialogo incorporata, per i più pigri); per ogni interazione con
il database, è possibile indicare se l’operazione è asincrona oppure “bloccante”;
 l’uso di SQL pre-processing, cioè la capacità di elaborare gli statement SQL da eseguire alla ricerca di
sequenze di escape, macro espandibili, costanti condizionali per script compatibili con diversi database,
oltre al riconoscimento intelligente dei marcatori per i parametri;
Nel corso della sessione, Dmitry ha mostrato diversi demo per dare prova dell’effettiva tangibilità delle
caratteristiche di AnyDAC nello sviluppo di applicazioni database-bound.
Uno degli obiettivi principali di AnyDAC, oltre a fornire driver universali per parecchi database dalle ottime
performance, è anche quello di consentire la scrittura di “codice SQL” nel modo più “universale” possibile,
eventualmente con istruzioni dinamiche, slegando quindi la propria applicazione dal database in uso o, per dirla
in altre parole, rendendola compatibile con qualsiasi database, e anche ai vari “dialetti” esistenti per ciascuno di
essi.
Non è però sempre necessario scrivere codice SQL in qualsiasi occasione: AnyDAC è in grado di generare i
comandi in automatico e gestire (nell’ambito in cui solitamente è richiesto) i generatori (GENERATOR in
InterBase/FireBird), i campi IDENTITY (SQL Server) e tutti i registri contatori di questa tipologia, in modo
uniforme e indipendente dal database in uso.
Vi sono poi una pletora di altre funzionalità che non possono essere approfondite qui per motivi di spazio, per
cui mi limiterò a elencare quelle principali: connection pooling, supporto a Unicode, modalità disconnessa, cache
dei metadati, tabella in memoria (ADMemTable) potente come il ClientDataSet ma più veloce e flessibile e altre
ancora (per l’elenco completo, basta consultare la pagina ufficiale del prodotto: http://www.da-
soft.com/anydac).
A chiusura della presentazione, Dmitry ha illustrato l’attuale roadmap delle novità previste per AnyDAC, tra cui il
supporto a Local SQL Engine e Nexus DB, l’introduzione di un driver DataSnap, l’integrazione di un Object
Persistence Framework e l’approdo anche sulla piattaforma Android.
Non ci resta che attendere per vedere come si evolverà questo già ottimo prodotto!
Microsoft: Azure
(Pietro Brambati – Microsoft Italia)
Pietro Brambati ha presentato le caratteristiche principali della nuova versione della piattaforma cloud di
Microsoft: Windows Azure (https://www.windowsazure.com).
Nella sua ultima release, Azure ha compiuto notevoli passi avanti, evolvendosi dall’essere una sorta di PaaS
(Platform as a Service) amministrabile, fino a diventare una soluzione completa che racchiude servizi di hosting,
macchine virtuali, storage, servizi di comunicazioni e deploy in un’unica architettura integrata a marchio
Microsoft.
Banalizzando al massimo, Windows Azure può essere considerata una piattaforma in cui fare il deploy di
pacchetti e applicazioni sviluppati in locale (con Visual Studio o altri tool e sistemi operativi compatibili con
Azure).

18. 18
Tramite una console amministrativa (migliorata rispetto alla versione precedente) è possibile controllare la
configurazione del proprio sistema. E’ possibile effettuare rilasci di pacchetti software sia verso un ambiente di
staging sia in produzione, trasferendo i pacchetti rilasciati da un ambiente all’altro con un solo clic (e
monitorando l’avanzamento del processo dalla console), con possibilità di effettuare un “rollback” o
mantenendo una “storia” (versioning) dei pacchetti rilasciati.
Le richieste che vengono inoltrate alle applicazioni ospitate in cloud sono già automaticamente in load
balancing. Dalla console amministrativa è possibile scalare istantaneamente verso l’alto o verso il basso,
aumentando il numero di macchine virtuali a disposizione dell’applicazione e sfruttando quindi le potenzialità
dell’ambiente cloud. In tutti i casi, il concetto applicato è quello del “Pay Only For What You Use”, con
fatturazione a ore delle risorse consumate calcolate al dettaglio.
L’eventuale “escalation” delle risorse richieste può seguire diversi pattern selezionabili a piacimento, in base
alle esigenze e al budget allocato; ad esempio, un pattern di tipo “On and Off” può consentire di accendere e
spegnere un’applicazione allocando risorse dedicate solo in determinate fasce orarie, mentre altri pattern
possono regolare la curva di risposta del sistema all’aumento di richieste. Il numero delle macchine virtuali, che
sono avviate in automatico, le loro risorse hardware e i relativi limiti sono pienamente configurabili, anche con
regole “custom”. E’ possibile definire inoltre “virtual machine” fisse, selezionabili da una gallery di soluzioni, che
montano ad esempio Windows Server 2008 R2, creabili con un file VHD ed eventualmente georeplicate, a cui si
può effettuare l’accesso via RDP.
Nel demo mostrato da Pietro Brambati, partendo da un progetto esistente ASP.NET realizzato con Visual Studio,
si procede con la creazione di un profilo (Windows Azure Publish Settings) per la pubblicazione successiva sulla
piattaforma Azure. Il profilo con tutti i dati può essere scaricato con comodo anche dalla console amministrativa
e successivamente importato nel progetto. Le applicazioni stesse possono invocare delle API specifiche di
Windows Azure, in modo da ottenere informazioni sullo stato del sistema e sfruttare determinate funzionalità
fornite dalla piattaforma. E’ possibile eseguire il debugging simulando l’esecuzione nell’ambiente Azure.
Oltre a consentire una gestione elastica e “al consumo” di risorse hardware in modo scalabile, Windows Azure
allevia l’onere della gestione dell’infrastruttura, in quanto questa è gestita da Microsoft, fornendo strumenti
intuitivi per il controllo e il “tuning”, oltre a statistiche di utilizzo delle applicazioni, disponibili sia in ambiente di
“staging” che produzione.
Windows Azure non si limita ad ambienti virtualizzati, ma include numerosi altri “pezzi” (building block)
sfruttabili dallo sviluppatore, quali servizi di storage, messaging, security, identity e così via (una parte di questi è
già sfruttabile in Delphi, tramite la Cloud API).
Accennando ai servizi di storage principali, abbiamo il componente “Blob Storage” che rappresenta un servizio
distribuito molto simile a un file system, utile per immagazzinare BLOB (Binary Large Object) che – grazie al
supporto del cloud – sono ridondati automaticamente e disponibili ovunque; con il servizio di SQL Database
invece è possibile creare istanze di database, anch’esse ridondate in modo del tutto automatico, per l’utilizzo da
parte di siti Web e applicazioni ospitate sul cloud, di cui si possono programmare in libertà backup e altre
operazioni di manutenzione; il servizio di Table Storage rappresenta il servizio di memorizzazione dati di tipo No-
SQL presente in Azure.
Parlando del messaging, Azure fornire code per lo scambio di messaggi. Il “Service Bus Queue” è un sistema di
tipo Publish/Subscribe che può essere sfruttato nel cloud, o in reti esterne, registrandosi all’endpoint. E’
possibile quindi costruire scenari ibridi, dove l’infrastruttura cloud di Azure permette di scalare anche solo parte
di un sistema software che comunica con le altre componenti, oppure migrare gradualmente l’applicazione.

19. 19
Il servizio Windows Azure Web Sites permette di creare con pochi clic e ospitare sul cloud siti basati su diversi
linguaggi (es. ASP.NET, PHP, Node.js, ecc.) oppure noti CMS, come Wordpress, disponibili in shared host e
scalabili su un server dedicato. L’architettura consente di condividere la cache tra siti che possono essere
opzionalmente distribuiti su diversi data center.
In occasione del recente lancio della nuova versione di Windows Azure, Microsoft propone alle aziende “startup”
e alle Subscription di Visual Studio Ultimate un bonus da spendere su Azure per testare e utilizzare la
piattaforma a tutti gli effetti.
Per conoscere tutte le condizioni e il costo dei servizi, è sufficiente andare sul sito ufficiale
(https://www.windowsazure.com) nella pagina dei “Prezzi”. L’offerta attuale prevede la possibilità di creare
gratuitamente 10 siti in shared hosting.
RemObjects: Beyond Remoting
(Claudio Piffer)
L’intensa giornata dedicata ai componenti di terze parti si è conclusa con la “concentratissima” sessione di
Claudio Piffer, che ha descritto nel dettaglio le funzionalità e alcuni scenari d’uso dei componenti di spicco
prodotti da RemObjects (l’azienda che si occupa anche – tra le altre cose – di Delphi Prism).
In particolare, si è parlato dei prodotti RemObjects SDK, Data Abstract e Hydra, disponibili per più piattaforme,
compresi in alcuni casi .NET, FireMonkey e Java.
RemObjects SDK è un remoting framework, un sistema in grado di consentire la chiamata di metodi su oggetti
che risiedono in macchine remote, così come avviene in modo simile a DataSnap, per quanto RO SDK vada ben
oltre le potenzialità offerte dalla libreria fornita di serie con Delphi, al punto che la definizione stessa di semplice
“remoting framework” è piuttosto limitativa.
RO SDK è estremamente semplice da configurare, è efficiente nel trasferimento dei dati, è flessibile
nell’utilizzo ed è facilmente estendibile. Il framework fornisce componenti server per tutti i principali tipi di
librerie a supporto della comunicazione (Indy, Synapse, WinINet, …) oltre a supportare la connessione Super
TCP-HTTP per una comunicazione “a due vie” tra client e server.
Il funzionamento del framework si basa sullo scambio di Messages: si tratta di dati che possono essere
trasmessi da un’applicazione all’altra utilizzando diversi formati, selezionabili a piacimento tra quelli principali o
necessari in base ai requisiti (es. SOAP, XML-RPC, JSON, ecc.).
Lo scambio prevede che il messaggio venga racchiuso all’interno di una Envelope (busta) prima di inviarlo;
l’utilizzo delle Envelope permette di compiere delle operazioni sul messaggio prima di inviarlo, ad esempio
crittografandolo con AES, per poi estrarlo o rielaborarlo al momento della ricezione. I tipi di Envelope sono
facilmente estensibili ereditando da una classe specifica messa a disposizione dal framework.
Ma RO SDK non si ferma qui. Dal punto di vista applicativo, mette a disposizione i cosiddetti Smart Services: si
tratta di servizi di trasporto che si premurano esclusivamente dell’invio e ricezione dei messaggi.
La creazione di un servizio con RO SDK avviene tramite un comodo wizard (disponibile per Delphi 7 sino ad
arrivare a Delphi XE2); il tipo di progetto più “comodo” da creare è il Combo Service Stand Alone, che semplifica
le operazioni di debugging della logica implementativa. In fase di build del servizio, il framework RO SDK
integrato in Delphi produce un file sorgente con la classe che definisce la struttura del servizio, in modo del
tutto similare a quanto avviene nella creazione di un oggetto COM all’interno di un COM Server in Delphi.

20. 20
L’interfaccia del servizio, cioè i metodi che mette a disposizione, può essere definita utilizzando l’apposito tool: il
RemObjects Service Builder; in modo simile all’editor di Type Library COM in Delphi, consente di definire tutti gli
elementi che compongono il servizio. Questo processo genera un file RODL: è un file in formato XML che
riproduce la struttura dei servizi.
Nell’IDE di Delphi viene inoltre integrato un Service Launcher che permette di mandare in esecuzione il servizio
per attività di test o debugging tramite un semplice comando.
Collegandosi al servizio via HTTP, è possibile usufruire automaticamente di informazioni sulla struttura del
servizio stesso (ad esempio, i metodi invocabili) e la relativa documentazione, se disponibile.
Il framework che gestisce la vita del servizio integra il Session Management: tramite un “client ID” scambiato tra
server e client (immagazzinato lato server in diversi modi, ad esempio in memoria o su database) il server è in
grado di mantenere la sessione attiva del client (e tutte le variabili di contesto che ne fanno parte),
analogamente a quanto avviene in tutte le moderne applicazioni Web.
Esistono poi diverse “class factory” che consentono di determinare la modalità di creazione dell’istanza del
servizio al momento dell’invocazione, ad esempio creando l’oggetto a ogni tentativo di chiamata dei suoi
metodi, oppure una sola volta per ciascun client, o una sola volta per l’intera vita dell’applicazione.
La tecnologia ROZeroConf consente di produrre automaticamente informazioni di “service discovery”.
Maggiori informazioni sul prodotto si trovano alla pagina ufficiale: http://www.remobjects.com/ro.
Successivamente, è stato preso in esame il prodotto Data Abstract: si tratta di un framework che consente
l’accesso ai dati con funzionalità molto simili a quelle di un ORM (ad esempio, Entity Framework), giusto per dare
un’idea di massima del tool di cui stiamo parlando.
Il pacchetto include il RO DA Schema Modeler: consente di definire le entità con cui l’applicazione deve
lavorare, eventualmente importando la struttura del modello da un database esistente, che costituisce lo
storage utilizzato per la persistenza dei dati. Sono supportati i database più noti. Il modello può essere
ovviamente modificato, disaccoppiandolo dalla struttura fisica delle tabelle da cui ha avuto origine.
Il framework supporta un linguaggio SQL personalizzato (DA SQL), molto simile a LINQ 2 SQL (.NET), che
consente di interrogare in modo standard la base dati, effettuando addirittura operazioni di JOIN e UNION
cross-DB. Le regole di business vengono invece definite tramite scripting.
Il vantaggio nell’uso di questo prodotto risiede nella possibilità di disaccoppiare la logica applicativa dalla
gestione dell’accesso ai dati e sfruttare l’astrazione che il modello offre. Il pacchetto comprende anche RO SDK
e ne sfrutta determinate funzionalità.
Maggiori informazioni su questo prodotto si trovano qui: http://www.dataabstract.com.
Infine si è parlato di Hydra, un tool decisamente interessante: si tratta di un framework che permette la
creazione di applicazioni modulari e le realizzazione di architetture strutturate a plugin.
Fin qui nulla di fuori dall’ordinario. Tuttavia, va detto che – oltre a essere compatibile con progetti VCL, WPF
(.NET) e FireMonkey, solo per citare quelle che più ci interessano da vicino – il framework consente alle
applicazioni di integrare e utilizzare interfacce (anche visuali, ad esempio controlli) realizzate con sistemi diversi
ed eterogenei tra loro, sobbarcandosi le operazioni necessarie a consentire il colloquio tra le diverse
architetture e librerie.

21. 21
Particolarmente illuminante è il demo effettuato da Claudio dove un controllo WPF che visualizza barre colorate
viene integrato con pochissime righe di codice all’interno di un’applicazione nativa Delphi creata con la VCL.
Ma è anche possibile integrare controlli FireMonkey in applicazioni VCL
(quindi rappresenta un altra possibile soluzione, oltre al Mida Converter
descritto precedentemente, per una eventuale migrazione di progetti da
VCL a FireMonkey).
I plugin possono essere di due tipi: visuali e non visuali. A questi si
affianca inoltre la facoltà di creare un RemObjects Service Client: si tratta
di un servizio basato su RO SDK che funge da plugin e presenta il
vantaggio di poter essere sostituito “a caldo”, cioè senza riavviare l’intero
sistema.
Il framework perfeziona al massimo l’integrazione fra i controlli facenti
capo a diverse architetture e librerie riducendone i vincoli, senza che l’utente si accorga di nulla nell’utilizzo
dell’applicazione finale.
Il prodotto è longevo e stabile, con una documentazione (Wiki) in crescita costante, ed è previsto il supporto a
iOS non appena sarà disponibile il compilatore Embarcadero.
L’unico modo di provare efficacemente questa suite di componenti è scaricare la trial dall’indirizzo del sito
ufficiale: http://www.remobjects.com/Hydra.
Conclusioni
Concludo il reportage con alcuni pareri personali riguardo l’edizione 2012 del
Delphi Day italiano.
La distribuzione dei contenuti della conferenza a mio avviso è stata molto
equilibrata, con spazi ben bilanciati nella loro suddivisione tra sessioni tecniche,
presentazioni commerciali e dibattiti rilassati, oltre alle pause dedicate alle
chiacchiere con altri sviluppatori a base di caffè e dolci.
Devo ammettere che, almeno inizialmente, ero un po’ scettico sulla effettiva
godibilità della giornata dedicata ai componenti di terze parti: mi aspettavo una sequela tendenzialmente
piatta di marketing più o meno mascherato. E invece sono rimasto colpito per diversi motivi: le presentazioni
sono state sufficientemente ricche di demo, quindi abbastanza pratiche e incentrate al far capire quali sono le
reali necessità che i prodotti mostrati sono in grado di soddisfare in caso di bisogno.
Inoltre, devo prendere atto che – contrariamente a quanto molti sviluppatori possano credere, soprattutto
coloro che non utilizzano Delphi – il mercato dei componenti di terze parti per il linguaggio e l’IDE di “via
Embarcadero” è fiorente e annovera prodotti estremamente potenti da un lato (penso ad esempio ai tool di
RemObjects, oppure a AnyDAC), capaci di superare le caratteristiche di strumenti equivalenti prodotti da
software house ben più grandi (come Microsoft) e fornendo un servizio eccellente nella verticalizzazione che
propongono, mentre dall’altro lato dimostrano anche come Delphi sia un tool estremamente versatile che
permette di sviluppare framework, librerie, applicazioni o strumenti per accelerare lo sviluppo abbracciando
senza difficoltà qualsiasi piattaforma lo si desideri. Questo grado di libertà e ampiezza di scelta da un linguaggio
che ha ben 17 anni e dimostra di essere ancora vivo, vegeto e “pimpante”, al giorno d’oggi non credo sia da
scartare, e ci sono ancora tante novità in arrivo! Long life to Delphi!