Reportage Delphi Day 2012

781 views
650 views

Published on

Il reportage dell'undicesima edizione del Delphi Day.

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
781
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
3
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Reportage Delphi Day 2012

  1. 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. 2
  3. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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!

×