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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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!