Ebbene sì, ho il piacere di darvi il benvenuto al mio nuovo canale Twitch, uno dei social network più popolari del momento.

Sono iscritto a Twitch da qualche mese. Nonostante un primo momento di scetticismo, ho iniziato ad apprezzare i contenuti fruibili su questa piattaforma, o meglio i contenuti prodotti dai cosiddetti “streamer”, e la gamma di strumenti che mette a disposizione. E così, in via del tutto sperimentale, ho iniziato a progettare il mio canale.

Prima di parlarne, facciamo alcune premesse.

Che cos’è Twitch?

La domanda potrebbe apparire scontata, ma non lo è. In qualità di “diversamente giovane” (per non dire boomer) ero convinto che Twitch fosse un sito dedicato esclusivamente al gaming online.

Ho scoperto poi che questa credenza era parecchia diffusa tra amici, collaboratori e conoscenti. Sebbene i videogiochi la facciano da padrone su Twitch, in realtà il social dal colore viola tratta un’ampia gamma di temi, dalla politica alla cucina, dalla musica al cinema, dall’intrattenimento comico al rilassamento interiore (con i caratteristici “artisti dell’ASMR“).

Qualunque cosa possa essere fatta da chiunque e trasmessa in diretta (scambio di opinioni, disegno, pittura, programmazione, esperimenti scientifici, preparazione di pietanze ai fornelli, gioco al videogame di grido, fitness, ecc.) se può essere interessante, ecco che può diventare una idea buona per un nuovo canale Twitch.

L’obiettivo dichiarato di Twitch è quello di trasformare lo streaming live in una esperienza divertente e godibile. Ciò vale sia per colui che conduce la diretta, sia per gli spettatori che vi partecipano.

Perché proprio Twitch?

Twitch non è l’unico portale che supporta eventi live: anche YouTube consente di fare streaming in diretta, ad esempio. L’esperienza offerta da YouTube tuttavia si può considerare poco più di una visione collettiva di un video con chat annessa. Twitch invece offre una serie infinita di strumenti con cui è possibile interagire.

La filosofia di Twitch è massimizzare la cosiddetta “gamification” applicata allo streaming live. Si può interagire con l’host e i partecipanti tramite la chat, usando anche emoticon esclusive del canale. Più tempo si trascorre guardando la diretta, più bonus si raccolgono. Grazie ai bonus, si possono lanciare “meme” o avanzare richieste all’host del canale. Vi sono poi opzioni per rimanere aggiornati sulle trasmissioni programmate o per iscriversi al canale supportandolo direttamente. E’ possibile accedere a live pre-registrate, disponibili pubblicamente o solo per gli abbonati. In breve, le possibilità sono infinite, sia per chi trasmette sia per chi riceve.

Alla fruibilità e godibilità degli eventi contribuiscono inoltre anche le politiche messe in atto dalla piattaforma. Nello specifico, vige tolleranza zero per tutte le forme nocive di partecipazione alle community: niente razzismo, niente violenza, niente maleducazione. La buona accoglienza sui canali è incentivata e, grazie ai moderatori (anche automatizzati), quasi garantita (nei limiti delle possibilità).

Canali interessanti per sviluppatori

Su Twitch seguo diversi canali che parlano di programmazione (in italiano) e dintorni, che vi segnalo con piacere.

Fabio Biondi (Microsoft MVP e Google Developer Expert, formatore e speaker) parla di sviluppo frontend con JavaScript e i framework Angular e React (ma non solo).

Marco Minerva (Microsoft MVP, developer e noto speaker) parla di .NET e sviluppo con tecnologie Microsoft.

Emanuele Bartolesi a.k.a. Kasuken (Full Stack Web Developer) parla invece di tecnologie cloud (Microsoft Azure) e di sviluppo frontend in generale. Questo solo per citarne alcuni: magari dedicherò un post apposito per segnalarvi i miei canali preferiti. 😉

Seguo poi altri canali decisamente più frivoli e orientati all’intrattenimento, ma al momento non voglio svelarli per non compromettermi più del dovuto. 😅

Veniamo al dunque: il mio nuovo canale Twitch!

Da dove è venuta l’idea di aprire un canale Twitch? Diciamo che da qualche tempo stavo coltivando l’idea di produrre contenuti in formato video, che è senz’altro il mezzo ancora privilegiato (oltre all’audio, che sfrutto già in Delphi Podcast). L’idea di un canale YouTube mi lasciava perplesso: poco interattivo, molto “impostato” e formale. Non mi andava di pubblicare il classico tutorial con annesso “spiegone”: meglio qualcosa di più rilassante e più facile da preparare. Ad esempio, una sessione di “live coding” con possibilità di improvvisare e l’obiettivo di realizzare qualcosa assieme, esplorare una tecnologia, una libreria o un framework. E perché no, anche sbagliare clamorosamente! 😊

Ecco che Twitch si offre come piattaforma ideale per questo tipo di esperimento, ed ecco ciò a cui ho pensato.

La mia intenzione è quella di organizzare sessioni di live coding settimanali (della durata di circa due ore) con l’obiettivo di pianificare per ogni settimana almeno una sessione (possibilmente nello stesso giorno della settimana, impegni permettendo).

Ciascuna sessione tratterà un tema o un argomento particolare (a mia scelta o proveniente da richieste della community). Esso potrà riguardare lo sviluppo di un progetto, l’uso di un particolare linguaggio e/o tecnologia, la sperimentazione di una libreria o di un framework, l’applicazione di una metodologia e così via.

Data la natura partecipativa del mezzo e dell’iniziativa in sé, il feedback dei partecipanti sarà tenuto in serissima considerazione.

Come iscriversi al canale

Per iscriversi al canale, collegarsi innanzitutto al portale di Twitch e premere il pulsante Registrati. La procedura richiede solo pochi minuti. Una volta completata, è possibile accedere via browser o usando le app ufficiali per Android e iOS. Twitch è supportato addirittura dalla maggior parte delle Smart TV.

Una volta eseguito l’accesso, visita il canale “CompilaQuindiVa” e fai clic su Segui per ricevere le notifiche dei prossimi eventi.

Se vuoi ricevere una notifica per il prossimo live, accedi al calendario dei prossimi live e attiva il 🔔 Promemoria sull’evento che ti interessa.

Conclusioni

Approfitto dell’occasione per sottolineare ancora una volta il carattere “sperimentale” di questa iniziativa: sono solo uno “streamer” apprendista. Essendo alle prime armi con la piattaforma, è lecito aspettarsi imprevisti di ogni sorta. 👼

Detto questo, confido tuttavia di riuscire a condividere contenuti interessanti e utili. Sarà quindi molto utile e apprezzato il vostro feedback. Non esistate quindi a contattarmi via e-mail o sui social che trovate nella mia homepage.

Iscrivetevi al canale e… stay “twitched”! 😉

Pubblicato da Marco Breveglieri sul blog Compila Quindi Va e ripubblicabile solo citandone la fonte.

Negli ultimi mesi sono piacevolmente usciti molti libri sulla programmazione Delphi. Le tematiche spaziano dall’ottimizzazione di algoritmi all’incremento delle performance, dai design pattern alle pratiche per velocizzare al massimo la scrittura di codice in Delphi. Tra queste pubblicazioni ne troviamo una decisamente interessante e molto attesa: la DelphiMVCFramework Official Guide.

L’autore del libro oltreché principale mantainer del progetto è Daniele Teti (CEO di bitTime Professionals). Si tratta della guida ufficiale all’uso di DelphiMVCFramework, una delle librerie più conosciute e utilizzate per lo sviluppo di server REST in Delphi.

Se i termini utilizzati sino a ora ti sembrano completamente nuovi oppure oscuri, ecco una premessa che dovrebbe colmare questa lacuna.

Delphi e il Web

Nel corso della sua lunga vita, Delphi ha conosciuto (spesso prima di altri tool di sviluppo) le tecnologie che sarebbero diventate poi il fondamento delle future applicazioni.

Già dalla versione 3, Delphi includeva librerie per realizzare architetture multi-tier (MIDAS) e per la produzione di pagine HTML (WebBroker). Col tempo si sono affiancate soluzioni per lo sviluppo RAD di applicazioni Web (come IntraWeb). Esse erano del tutto simili alle idee proposte dalla concorrenza (es. ASP.NET Web Forms) per ottenere il medesimo risultato finale, ovvero esporre una GUI fruibile da qualsiasi browser in grado di collegarsi a una base dati.

Lo scenario tuttavia oggi è cambiato. L’approccio client/server, o n-tier, ovvero l’accesso a dati in rete locale non è più sufficiente. Lo stesso vale per le suddette applicazioni Web, troppo “pesanti” poiché incentrate sulla generazione lato server dell’intera GUI e poco efficaci nel presentare all’utente una esperienza simile a quella che può fruire lato desktop.

Brevemente, la necessità odierna è quella di disaccoppiare i database da qualsiasi tipo di interfaccia utente, sia essa una applicazione Web o un programma desktop, inserendo tra questi due elementi un server con lo scopo di fornire “mobilità” ai dati.

Let’s get some REST!

I linguaggi e le piattaforme con cui è possibile sviluppare un programma client sono molteplici: per questo è necessario che il server utilizzi un protocollo standard, ovvero HTTP, e adotti formati standard per il trasferimento dei dati, ad esempio XML.

Prima erano i Web Service…

Se pensi io stia parlando dei Web Service, stai sbagliando. Essi sono l’incarnazione del primo (e ancora molto diffuso) tentativo di realizzare API standard. L’uso del protocollo HTTP è però marginale poiché limitato al trasporto dei pacchetti. I pacchetti sono basati su uno standard quale è SOAP che, sebbene abbia la parola “Simple” nel nome, può diventare estremamente ostico se si ha a che fare con le sue estensioni. Usare un Web Service richiede inoltre la conoscenza delle operazioni che implementa: è necessario recuperarne la struttura documentata con un altro standard, il caro WSDL. Tutto troppo complicato, e soprattutto troppo rigido per le esigenze di oggi.

HTTP come protocollo “principe”

Proviamo ora a fare una ricetta. Prendi il protocollo HTTP. Immagina ora che, al posto di pagine Web tradizionali, si trasferiscano dati di clienti, fornitori, fatture e così via. Sostituisci poi il linguaggio HTML con documenti XML semplici (non SOAP!) o con strutture ancora più rastremate come JSON. Pensa poi all’indirizzo URL come alla locazione universale e parlante di una “risorsa” (un cliente o una fattura) invece che di una pagina Web. Ora i comandi HTTP: oltre ai più noti GET e POST, includi almeno anche PUT e DELETE trasformando questi “verbi” nella classica tavola CRUD. Ora pensa ai codici di stato che HTTP fornisce in risposta: ad esempio, il più conosciuto, il classico “errore 404”, non indicherà l’impossibilità di trovare una pagina, bensì una delle tue risorse. Amalgama il tutto ed ecco che avrai qualcosa di molto simile a un (goloso e fumante) server REST!

Tutto ciò però ha una implicazione: non possiamo fare finta che HTTP non esista e trattarlo come un mero veicolo di dati, ma dobbiamo padroneggiarlo come si deve. Nel fare questo, dobbiamo anche rispettare scrupolosamente le convenzioni che gli sviluppatori di eventuali client per la nostra API si attendono. Idealmente, dovremmo puntare al livello più alto del Richardson Maturity Model, il cosiddetto “Glory of REST”.

Delphi e il suo ecosistema ci offre diverse alternative. Potremmo decidere di lavorare a basso livello usando direttamente WebBroker. Oppure potremmo beneficiare di un minimo di astrazione in più con i componenti Indy. Ridurremmo ulteriormente lo sforzo se adottassimo una delle tante librerie ad hoc disponibili per Delphi; ad esempio, RAD Server è una soluzione “chiavi in mano” già disponibile dall’edizione Enterprise. Perché non pescare invece tra le tante librerie open source? Ne possiamo scegliere una popolare, semplice, flessibile e – grazie al libro oggetto di questa recensione – anche ottimamente documentata: DelphiMVCFramework!

Prima di passare a parlare della DelphiMVCFramework Official Guide, partiamo dall’ABC… o meglio, da MVC. 😄

Il pattern MVC

MVC (Model View Controller) è un pattern architetturale in uso da parecchi anni. Esso è stato creato con lo scopo di separare la logica di presentazione da quella di business.

Il pattern è tornato in voga soprattutto nell’ambito dello sviluppo Web poiché costituisce la colonna portante di librerie e framework particolarmente noti e apprezzati, sia lato client (come AngularJS) sia lato server (ad esempio Ruby On Rails o ASP.NET MVC).

Il suo successo deriva dalla semplicità con cui permette di creare soluzioni software altamente disaccoppiate. Questo benefit deriva sia dall’adesione stretta al pattern, ma anche dagli strumenti (classi base, attributi, decoratori, convertitori, ecc.) apportati dai framework che vi si appoggiano. Questi elementi combinati con l’efficacia del pattern consentono di implementare agevolmente le feature dell’applicazione. Ciò avviene non solo aggiungendo la propria logica di business, ma creando estensioni agli stessi framework. L’intera architettura rimane sempre e comunque perfettamente mantenibile, quasi un tributo al Clean Code! Ciò vale per tutti i framework citati, e ovviamente anche per DelphiMVCFramework.

DelphiMVCFramework alla riscossa!

Se non conoscete minimamente DelphiMVCFramework, dovete rimediare subito!

Vi sono diverse risorse che permettono di acquisire una panoramica veloce su ciò che potete realizzare con il framework. Ad esempio, potete guardarvi questo corso introduttivo di un paio d’ore (in lingua italiana) tenuto dallo stesso Daniele. Se siete di fretta, ci sono i filmati della recente DMVC Week su YouTube. Se siete in macchina o state correndo all’aria aperta, potete ascoltare l’intervista a Daniele Teti in questo episodio di Delphi Podcast.

Il codice sorgente del framework può essere scaricato direttamente dal repository ufficiale di GitHub, nel quale trovate anche un elenco delle funzionalità presenti nell’ultima versione (nel momento in cui scrivo), la 3.2.1 codename “carbon“.

Solo per dare una idea delle potenzialità, guardate quanti tipi di oggetti si possono restituire ai client usando un solo metodo, Render():

Non mi dilungherò a elencare nel dettaglio l’elenco impressionante di feature che il framework vi mette a disposizione. Farlo richiederebbe un libro intero per descriverle tutte minuziosamente.

Aspetta un momento… un libro c’è già. E’ la DelphiMVCFramework Official Guide! 🙂

DelphiMVCFramework Official Guide: una guida imperdibile!

La DelphiMVCFramework Official Guide è il testo indispensabile per creare il tuo server ed esporre la tua API sfruttando la potenza di REST o di JSON-RPC e usando uno dei framework più popolari e completi per Delphi.

La prima pubblicazione completa della guida risale a metà settembre, e può essere acquistata sul sito LeanPub. Oltre al classico PDF, è disponibile anche nei formati EPUB (per telefoni e table) e MOBI (per Kindle).

Si tratta di un testo imperdibile per qualsiasi sviluppatore Delphi, e ora ne illustro tutti i motivi.

Innanzitutto, non si tratta di una banale guida introduttiva al framework DMVC: essa esplora nel dettaglio tutte le sue caratteristiche in modo approfondito. E’ pertanto una preziosissima risorsa per imparare a usare come si deve il framework e ottenere il massimo potenziale dallo stesso.

Il pattern MVC spiegato bene

Nell’illustrare tutti gli strumenti che il framework mette a disposizione, Daniele spiegherà MVC e tutti gli attori che fanno parte di questo paradigma. Imparerai quindi a conoscere il pattern MVC in modo approfondito. Oltre a DelphiMVCFramework, queste nozioni ti consentiranno di usare con sicurezza tutti gli altri framework disponibili per altre piattaforme e linguaggi che si basano sullo stesso pattern (ad esempio, ASP.NET MVC, oppure NodeJS Express, Angular, RoR e tanti altri ancora).

REST a regola d’arte

La guida ti darà inoltre un ulteriore valore aggiunto: la spiegazione dettagliata di come creare una API REST perfetta. Apprenderai i segreti per implementare i verbi HTTP nel modo corretto, definire gli URL di accesso alle risorse. E ancora, quale formattazione usare nella ricezione e restituzione dei dati, i codici numerici di risposta e così via. Insomma, la tua sarà una API che implementa REST (o JSON-RPC, se lo preferite) rispettando tutte le convenzioni. Con questo bagaglio di conoscenze, potrai creare agevolmente anche qualsiasi applicazione client, dialogando magari con server sviluppati da terzi, ma aderenti alle stesse regole. Oppure ancora potrai riusare queste nozioni nella creazione di server REST con altre librerie e altri linguaggi su ecosistemi differenti (es. ASP.NET Core Web API).

DelphiMVCFramework non ha più segreti

Riguardo DMVC nello specifico, il libro fornisce una panoramica chiara, esaustiva e completa del framework. Si parte dalla sua installazione e configurazione, creando quasi da subito il primo progetto. Dopo aver mosso i primi passi, si aggiungono nuovi scenari e requisiti aumentando la complessità. Questi espedienti permettono di scoprire gradualmente gli strumenti che il framework mette a disposizione per risolvere ciascun problema. I requisiti presi in esame, pur trattandosi di esempio, sono comunque sempre concreti e pratici, mai astratti o surreali.

Tanti tool aggiuntivi, piccoli ma potenti

Per testare il tuo server REST e svolgere tante altre operazioni di contorno, oltre al classico browser, farai uso di interessanti tool specifici (ad esempio, cURL). Daniele ti spiegherà anche come usare Python per invocare la tua API. La conoscenza di questi programmi può tornare utile nel caso si voglia adoperarli anche in altri contesti differenti.

Esempi chiari

Una scelta che ho particolarmente apprezzato è quella di riportare esempi di codice mirati. Gran parte dei libri in circolazione rimanda solamente al codice di esempio a corredo, da scaricare e aprire mentre si legge. Ritengo invece encomiabile che ogni trattazione di uno specifico argomento riporti sul libro la parte di codice interessata, privata di tutto ciò che è estraneo. Questo consente di seguire tranquillamente il testo senza avere lo schermo con il codice aperto davanti. Potrai quindi esplorare le feature di DMVCFramework leggendo il libro a letto prima di dormire. Quando ti alzerai il giorno dopo, e sarai davanti al PC, potrai esercitarti su quanto imparato. Il codice sorgente completo è comunque disponibile per il download sul sito LeanPub.

La cura dei dettagli c’è (e si vede)

Un altro pregio credo sia quello di aver istituito un preciso vocabolario tecnico. Il framework è molto vasto, quindi dare un nome preciso a ogni cosa che contiene è senz’altro di aiuto. Non vi è confusione o ambiguità su ciò che fa un Controller, una System Action o una Strongly Typed Action, o su cosa sono gli URL Mapped Parameters. L’adozione di termini specifici per determinati strumenti aiuta la formazione, ma anche la descrizione circostanziata di eventuali problemi quando si ha bisogno di supporto. A tal proposito, se sei in difficoltà o ti piace aiutare gli altri sviluppatori della community, iscriviti al gruppo Facebook.

Infine, laddove gli elenchi puntati sarebbero stati sufficienti, al loro posto spesso vengono usate delle tabelle riepilogative. Questo permette di “espandere” la definizione di ciascun elemento con note ed esempi chiarificatori.

Nel testo vi sono inoltre svariati diagrammi e grafici. Queste decisioni stilistiche vanno a tutto vantaggio della comprensione dei concetti. Si tratta forse di piccolezze, ma la cura dei dettagli si vede e porta i suoi benefici.

Conclusioni

Qualora non sia ancora del tutto chiaro, DelphiMVCFramework Official Guide è un testo che non deve assolutamente mancare nella tua libreria tecnica!

Che tu voglia iniziare a usare DMVC o che tu abbia intenzione di usare un’altra libreria, il libro può esserti comunque di estremo aiuto per capire MVC, REST, JSON-RPC e altri tasselli del mondo in cui stai per addentrarti.

Se invece usi già DMVC nei tuoi progetti, il libro ti servirà per approfondirne la conoscenza a 360° ed esplorare nuovi modi per estendere e “carrozzare” la tua API.

Ora non hai più scuse per rottamare la tua vecchia soluzione client/server e portarla (finalmente) nel nuovo millennio. Ciò è ancora più giustificato dalla pletora di strumenti che DMVC ti rende disponibili per esporre risorse con un’attenzione particolare al riuso del codice eventualmente già esistente, come da tradizione Delphi.

Il framework c’è, e ha raggiunto una invidiabile maturità. Ora che c’è pure il manuale d’uso. Cosa aspetti ad accaparrartelo e iniziare a programmare? 😉

Pubblicato da Marco Breveglieri sul blog Compila Quindi Va e ripubblicabile solo citandone la fonte.

Come anticipato nel post di qualche giorno fa, si tratta dei webinar che ho tenuto nei giorni scorsi per la community di Delphi & Dintorni.

Replay dei webinar

Qui di seguito trovate:

• i filmati pubblicati sul canale YouTube di Wintech Italia,
• i collegamenti per il download del materiale a corredo (slide ed esempi di codice).

Padroneggiare i principi SOLID

Molti sviluppatori continuano a porsi ancora oggi domande esistenziali, ad esempio “Come posso scrivere codice mantenibile?” oppure “Come posso rendere il codice testabile?“. Purtroppo non ci sono keyword, né talismani che possano donare la qualità di essere “buono” al nostro codice senza sforzo, tuttavia è sufficiente rispettare pochi e sani principi di progettazione, detti principi SOLID. In questo webinar vedremo come soddisfare tali principi e scrivere “buon codice” con Delphi, rendendolo stabile, mantenibile, estensibile, comprensibile e scalabile, aprendo nel contempo la porta ad altri scenari visti talvolta con diffidenza, come il Testing, che diverranno così semplici e addirittura automatici.

Diventa un mago del Testing

Il Testing è una pratica sempre più preziosa e fondamentale nell’ambito dello sviluppo del software: si tratta di un passaggio fondamentale per ridurre il numero dei bug nel software e abilitare automatismi come la Continuous Integration e la Continuous Delivery. Se utilizzati in modo errato però, i test possono causare più problemi di quanti ne prevengano: è importante quindi conoscere le differenze tra le varie tipologie di test, quali sono le loro caratteristiche ideali e padroneggiarli al meglio. In questo webinar faremo luce sul Testing, chiariremo bene i concetti di Unit e Integration Test, vedremo come scriverli nel modo corretto e quali tool ci vengono in aiuto… alla fine il Testing non avrà più segreti!

Buona visione! 🤗

Pubblicato da Marco Breveglieri sul blog Compila Quindi Va e ripubblicabile solo citandone la fonte.

Le iniziative

Andrea Magni ha dato vita a Delphi Live Italia. Si tratta di una serie di incontri virtuali, ciascuno dedicato a un tema tecnico. Ogni appuntamento vede un “conduttore” designato che espone la propria esperienza. Tutti hanno la facoltà di partecipare e porre domande sul tema trattato. Il collegamento avviene sfruttando Lumicademy, una piattaforma di teledidattica realizzata proprio con Delphi.

Daniele Teti e bitTime Software hanno erogato un corso rapido su Delphi MVC Framework, il framework per lo sviluppo di applicazioni Web REST più diffuso, e un evento introduttivo sulla creazione di videogiochi con Unity.

Paolo Rossi di Wintech Italia ha invece inaugurato il nuovo sito di Delphi & Dintorni. D&D è la storica community italiana di Delphi, nata anni fa attorno ai newsgroup gestiti un tempo dal patron Marco Cantù. Paolo ha ripreso inoltre l’invio della newsletter “D&D Online”. Infine, è nata una serie di Webinar completamente gratuiti, dove vari esperti si avvicendano per trattare argomenti tecnici relativi allo sviluppo con Delphi, ma non solo.

Sino a oggi tutti gli eventi sono stati tutti accolti con molto interesse. Tutte le sessioni sono state partecipatissime, con un numero di adesioni medio non inferiore ai 60 utenti iscritti e attivi online: un successo assoluto!

I miei webinar online gratuiti

Quando c’è l’occasione di partecipare a qualche bella iniziativa rivolta agli sviluppatori, sapete che non mi tiro indietro. Con modesta fantasia, ho cercato di proporre qualche argomento che possa essere di interesse ai miei “colleghi”. 😅

Ho pensato a un paio di webinar su argomenti che mi stanno particolarmente a cuore. Ho scoperto (dopo) che si inseriscono peraltro particolarmente bene nel filone dei temi trattati dai webinar Delphi & Dintorni che precedono e che seguono.

Ecco quindi una breve descrizione dei webinar online gratuiti che ho proposto e che terrò nei prossimi giorni.

E se ancora non usi Delphi, è un’ottima occasione per scaricare l’edizione Community e iniziare.

Padroneggiare i principi SOLID

Molti sviluppatori continuano a porsi ancora oggi domande esistenziali, ad esempio “Come posso scrivere codice mantenibile?” oppure “Come posso rendere il codice testabile?”.

Purtroppo non ci sono keyword, né talismani che possano donare la qualità di essere “buono” al nostro codice senza sforzo. Bisogna rispettare pochi e sani principi di progettazione, e i principi SOLID sono fra questi.

In questo webinar cercherò di illustrare con esempi (possibilmente semplici ma calzanti) come soddisfare tali principi. Vedremo come scrivere “buon codice” con Delphi, rendendolo stabile, mantenibile, estensibile, comprensibile e scalabile. Apriremo quinid la porta ad altri scenari visti talvolta con diffidenza, come il Testing, che diverranno così semplici e addirittura automatici.

Il webinar si terrà venerdì 8 maggio alle ore 15.00: iscriviti subito qui!

Diventa un mago del Testing

Il “Testing” è una pratica sempre più preziosa nell’ambito dello sviluppo del software.

Si tratta di un passaggio fondamentale per ridurre il numero dei bug nel software e abilitare automatismi come la Continuous Integration e la Continuous Delivery.

Se utilizzati in modo errato però, i test possono causare più problemi di quanti ne prevengano. E’ importante conoscere le differenze tra le varie tipologie di test, quali sono le loro caratteristiche ideali e padroneggiarli al meglio.

In questo webinar faremo luce sul Testing a 360 gradi. Chiariremo bene i concetti di Unit Test e Integration Test, vedremo come scriverli nel modo corretto e quali tool ci vengono in aiuto… alla fine il Testing non avrà più segreti!

Il webinar si terrà venerdì 15 maggio alle ore 15.00: iscriviti subito qui!

Conclusioni

Se il lavoro da remoto vi lascia un pochino di respiro, approfittate di questi webinar online: si tratta di una occasione unica per formarsi approfondendo argomenti tecnici interessanti, e ripartire ancora più di slancio quando questa emergenza sarà finita. 😉

Anzi, confido che diventino più frequenti, trasformandosi in una nuova e piacevole tradizione. 🤗

Cover Photo by Belo Rio Studio on Unsplash

Pubblicato da Marco Breveglieri sul blog Compila Quindi Va e ripubblicabile solo citandone la fonte.

Organizzata da bitTime Software (rappresentanza italiana di Embarcadero/Idera) e bitTime Professionals, l’evento è giunto alla decima edizione (da cui la “X” nel nome).

Per festeggiare il traguardo, lo staff ha curato tutto nei minimi dettagli: logo rinnovato, nuovo sito ufficiale, magliette dal design accattivante per partecipanti e speaker, videoripresa delle sessioni e tanto altro.

A fianco delle novità, permangono invece costanti come l’accoglienza, il supporto, la simpatia, il buon cibo e la buona compagnia che da dieci anni fanno da contorno ai contenuti tecnici della conferenza.

I miei contenuti preferiti a ITDevCon X

Anche questa edizione ha offerto un’ampia selezione di argomenti interessanti, in lingua italiana e inglese.

Vi sono state tuttavia alcune sessioni che ho particolarmente apprezzato per gli spunti che hanno fornito.

Ad esempio, Daniele Teti (CEO e R&D Director di bitTime Professionals) ha illustrato in modo chiaro l’uso di Kanban, il metodo per la gestione del lavoro che consente di individuare e risolvere i “colli di bottiglia” rendendolo più fluido e capace di soddisfare le scadenze. Pur avendolo visto e utilizzato in molte occasioni, ho riscoperto questo metodo chiarendo le caratteristiche base di questa metodologia. Daniele ha inoltre mostrato un demo di Kanboard, un software gratuito e open source per costruire la propria “Kanban Board”.

Diversi spunti li ho trovati anche nella sessione di Marco Mottadelli (CEO di DNA Software) dedicata a Jenkins: si tratta di uno strumento dedicato alla Continuous Integration, a cui ho accennato di recente. Grazie alla sua integrazione con diversi sistemi di Version Control, permette di generare build automatiche, eseguire test e svolgere tante altre operazioni nell’ambito DevOps grazie ai linguaggi supportati (es. batch o Python) e al supporto di vari plugin.

Altra menzione d’onore va a Omar Bossoni (BCI Software) per aver “sviscerato” il lungo processo che porta alla distribuzione di un’applicazione Delphi su iOS, il sistema operativo Apple per dispositivi mobili. L’iscrizione all’Apple Developer Program, la creazione dei profili necessari, la generazione dei certificati… Omar ha dettagliato tutto ciò che deve essere fatto per pubblicare la propria app. Dal punto di vista tecnico e burocratico, i costi e gli ostacoli non mancano di certo. Anche se suscettibile di frequenti cambiamenti, grazie a questa spiegazione il processo da oggi sarà meno oscuro e più agevole da portare a termine.

Estendere l’IDE di Delphi: slide e sorgenti degli esempi

La sessione che ho preparato per questa edizione di ITDevCon riguardava l’estensione dell’IDE di Delphi.

Più che una trattazione tecnica, il mio talk è stata una “moral suasion”: l’obiettivo era quello di stimolare la curiosità della community di sviluppatori allo scopo di incentivare la creazione di add-in per Delphi.

La maggior parte delle estensioni Delphi infatti è costituito da prodotti medio/grandi che aggiungono macro-funzionalità. A differenza della concorrenza (vedi il caso di Visual Studio Code), pochi sono i tool specifici e mirati per Delphi volti a risolvere piccole esigenze.

Delphi consente di estendere le proprie funzionalità grazie alla Tools API. Si tratta di una Unit che fornisce interfacce tramite le quali interagire con l’IDE per alternarne o integrarne le funzionalità, o ricevere segnalazioni relative a eventi significativi.

Fra gli esempi più curiosi che ho mostrato, sicuramente il successo maggiore lo ha avuto il demo “Code Smells”. Si tratta di un plugin che, una volta installato, emette suoni di flatulenze in presenza di errori al termine della compilazione. Grazie a una voce di menu dedicata e a una finestra di dialogo, il plugin è anche configurabile!

Sorvolando sul carattere goliardico e sull’utilità pressoché nulla del plugin, è un ottimo esempio di add-in verticalizzata: installa un menu, visualizza una dialog di setup, interagisce con la compilazione, inserisce messaggi nel log, riproduce suoni e così via.

Per chi è interessato, i sorgenti degli esempi e le slide mostrate durante la sessione sono scaricabili dal mio repository su GitHub.

Alcune foto da ITDevCon X

Potete visualizzare le fotografie che ho scattato durante l’evento nel mio album Google Foto condiviso.

Conclusioni

ITDevCon non mostra segni di vecchiaia. Nonostante gli anni, resta un appuntamento irrinunciabile. Tutto ciò è merito soprattutto dell’impegno e del lavoro degli amici di bitTime Software.

Gli argomenti permangono variegati e attuali, in un clima spensierato come sempre. Quest’anno ho incrociato volti conosciuti ma anche facce nuove, che è sempre un incoraggiante segnale di quanto la community Delphi sia vivace.

In sintesi, lo slogan “la miglior edizione di sempre” è stato rispettato appieno. 🙂

Pubblicato da Marco Breveglieri sul blog Compila Quindi Va e ripubblicabile solo citandone la fonte.

L’evento riguardava il tema DevOps, che sta prendendo sempre più piede presso sviluppatori, sistemisti, Project Manager e tante altre figure del mondo IT.

Nel corso della giornata si sono avvicendati vari speaker per chiarire meglio gli aspetti di questo controverso tema, provenienti dall’Italia e dall’estero. Grazie agli sponsor, la conferenza DevOps Heroes 2019 era completamente gratuita.

Tutte le informazioni sull’evento e le slide delle sessioni potete trovarle già sul sito ufficiale.

Cosa si intende con il termine DevOps?

Riprendendo la definizione riportata sul sito della conferenza, DevOps è una cultura, un movimento, una pratica che si focalizza su collaborazione e comunicazione. Il suo obiettivo è quello di colmare il gap fra i diversi attori coinvolti nella produzione del software. Essa collega lo sviluppatore di software alle altre figure IT impegnate nel test e nel delivery della soluzione, includendo metodologie ma anche tool. Il risultato finale è un ecosistema affidabile e automatizzato per fare sviluppo, build e release.

Avendo partecipato come tutti solo a determinate sessioni, il mio resoconto non potrà essere esaustivo. Mi limiterò quindi a riportare gli elementi di DevOps Heroes 2019 che ho trovato più interessanti.

Microsoft Learn: una bella scoperta!

Essendo sia partner che sponsor, Microsoft ha “monopolizzato” un pochino parte dei contenuti della conferenza.

Nel talk di apertura Aldo Donetti, Senior Regional Program Manager di Microsoft, ha illustrato le funzionalità del sito Microsoft Learn e le sue potenzialità.

Oltre a includere percorsi di formazione specifici per Azure, la soluzione cloud di Redmond, il sito è in grado di offrire esercitazioni pratiche creando automaticamente le risorse cloud che sono necessarie. Ciò consente a chiunque di apprendere l’uso della piattaforma eseguendo comandi reali su architetture veraci create ad hoc, senza dover necessariamente acquistare prodotti e servizi.

Il sito annovera decine e decine di nuovi corsi e offre la possibilità di iscriversi con un profilo che è possibile rendere pubblico per mostrare i propri progressi. Oltre ad autocelebrarsi, esporre i traguardi raggiunti può tornare molto utile, ad esempio per proporsi come candidato per una posizione lavorativa aperta.

Ricordo di aver visitato il sito di recente, ma non avevo notato tutte le novità che sono state raccontate: ci farò presto una capatina e consiglio a tutti di farlo.

Continuous Integration: qual è il reale valore?

La Continuous Integration (abbreviata in “CI”) è forse uno dei maggiori capisaldi della filosofia DevOps. Molte delle sessioni ha riguardato questa pratica, direttamente o indirettamente, parlando di tool e/o di configurazioni legate alla CI.

Nata con extreme programming (XP), si tratta di una pratica che prevede l’integrazione continua e frequente dei sorgenti all’interno di un repository. Ogni conferimento da parte degli sviluppatori scatena un processo di build automatizzata al fine di rilevare prematuramente eventuali errori di compilazione. Il successo della build in genere avvia l’esecuzione di test automatizzati sul prodotto. Se l’intera procedura va a buon fine, opzionalmente viene generato il pacchetto che rappresenta una nuova versione del software. Tale pacchetto può essere rilasciato sia in ambienti di test sia reso disponibile al cliente finale.

La domanda che è stata posta a riguardo è: qual è il fine ultimo di avere una “catena” simile? Per dirlo in altre parole, cosa non può mancare affinché la CI fornisca tutto il proprio valore?

Uno degli obiettivi primari della CI è avere feedback rapidi, che possono provenire sia dai tester che dai clienti finali. Prima giungono responsi in seguito a un nuovo rilascio, prima si possono aggredire eventuali problemi, come bug, errori o regressioni.

Senza test non esiste DevOps!

Per poter essere efficace, qualsiasi sistema di Continuous Integration non può esistere senza prevedere una adeguata strategia di testing. D’altronde, senza la presenza di test affidabili, non si potrebbe avere alcuna garanzia in merito alla qualità di ciò che il processo automatizzato produce in output. Ciò implica che i test dovrebbero essere anch’essi automatizzati.

Nell’implementazione di pratiche DevOps, può accadere di trascurare in toto o in parte l’importanza dei test, magari perché percepiti come inutili o costosi dal management, o perché mediamente complessi da implementare, soprattutto quando si parla di Unit Test. Talvolta l’effort percepito è più alto del costo reale, per cui si preferisce risparmiare sulla scrittura di test automatizzati, spendendo magari dieci volte tanto in risorse umane impiegate per fare clic sull’interfaccia, ossia test manuali.

E’ bene precisare che qualsiasi tipologia di test ha una propria utilità che non si vuole assolutamente sminuire in questo contesto. Il messaggio da recepire è che i test automatizzati hanno ben più valore, come indicato nel modello della Test Pyramid, e pertanto andrebbero favoriti come investimento proficuo nel medio/lungo termine.

Microservizi e… unicorni.

Un altro prodotto molto in voga come risultato di un processo guidato da DevOps sono i microservizi, paragonati più volte nel corso della giornata agli unicorni: se ne parla spesso, piacciono pure ma nessuno li ha mai realmente visti. 😊

Le critica nemmeno troppo velata si riferisce a quelle soluzioni software spacciate commercialmente come “micro services”, ma che in realtà non lo sono.

La denuncia è che i presunti microservizi siano spesso realizzati senza rispettare i dovuti crismi. Essi devono essere indipendenti, di piccole dimensioni e affidabili. Spesso invece ci si ritrova tra le mani soluzioni che sono banali “rebrand” del vecchio approccio SOA.

Uno dei fattori maggiormente trascurati è proprio quello dell’affidabilità intrinseca del singolo servizio, che diviene ancora più fondamentale quando invocato da altri servizi per soddisfare una richiesta.

Rendere un servizio “reliable” significa riuscire a gestire anche le situazioni in cui uno degli altri servizi restituisce errori, o risulta irraggiungibile, continuando a mantenere un elevata velocità nel fornire risposte ai client.

Nell’ambito della piattaforma Microsoft .NET (nelle versioni “tradizionale” e “Core”) è possibile usare Polly, una libreria che permette di rendere resiliente e “fault tolerant“ una parte di logica sviluppata in C# o VB.NET, implementando diverse strategie. Ad esempio, adottando il pattern Retry abbiamo la facoltà di ripetere una chiamata (o qualsiasi altra operazione) per un certo numero di volte prima di alzare definitivamente bandiera bianca; in alternativa, usando Circuit Breaker possiamo invece sopperire ai timeout persistenti di un servizio remoto restituendo immediatamente un errore. L’obiettivo è quello di garantire una velocità ottimale e costante di risposte al secondo.

A proposito, se volete mettere “alla frusta” la vostra Web API per verificare come si comporta in situazioni di stress, potete usare il tool Locust.

Azure DevOps Services

La piattaforma cloud maggiormente citata nel corso di DevOps Heroes 2019 non poteva essere che Microsoft Azure. In particolare, si è parlato molto dei servizi cloud esplicitamente dedicati alle pratiche DevOps, ossia Azure DevOps Services.

Si tratta di una piattaforma di servizi, disponibili in cloud ma anche on-premise, dedicati sia agli sviluppatori sia agli altri membri del team, dalla pianificazione delle attività allo sviluppo vero e proprio, dalla condivisione del codice sorgente alla gestione di tutti gli automatismi volti a fornire tutto quello che serve per la realizzazione e la distribuzione di software.

Molte sessioni hanno mostrato implementazioni personalizzate di processi DevOps sfruttando questa piattaforma, costruendo ad esempio delle pipeline di comandi per eseguire le build del software, o illustrando un esempio di flusso di lavoro basato sulle feature di ADS.

Il prodotto si è dimostrato molto versatile e capace di adattarsi a diversi scenari: ogni azienda tende a specializzare in modo estremo il proprio workflow, in base alle proprie esigenze e alle persone che costituiscono il team di lavoro.

Un altro punto a favore è l’estrema apertura verso l’integrazione di sistemi esterni, ad esempio SonarCloud. In breve, oltre a una personalizzazione spinta delle politiche di funzionamento, Azure DevOps può colloquiare con eventuali servizi esterni. In questo modo è possibile aggiungere tutto ciò che la piattaforma non è in grado di gestire.

Se si vuole dare un’occhiata e sperimentare con i servizi di Azure DevOps, Microsoft fornisce diversi piani alcuni dei quali gratuiti, per poter iniziare con una dotazione minima e provare con mano senza spendere nulla.

Conclusioni

Nonostante un piccolo cambio di programma dovuto a un’assenza imprevista, l’organizzazione di DevOps Heroes 2019 è stata pressoché impeccabile. Tempi rispettati, nessun intoppo particolare, cibo e caffé abbondanti, argomenti variegati: tutto si è svolto nel migliore dei modi.

Da alcune sessioni mi sarei aspettato forse un approfondimento maggiore, ma è probabile che non fosse possibile, sia per via del tempo ristretto sia per la vastità del tema, che ha davvero tante sfaccettature.

Per un “novizio totale” della DevOps come me, l’occasione è stata comunque utilissima per iniziare a toccare con mano la filosofia e le sue prerogative. Il termine DevOps e il movimento che rappresenta, inizialmente più fumoso, ha assunto un significato più chiaro e delineato. Interfacciarsi a un team che adotta queste pratiche o abbracciarlo direttamente è un compito meno arduo da oggi.

Continuerò senz’altro ad approfondire le mie conoscenze su DevOps, auspicando una nuova edizione dell’evento. Nel frattempo ci si rivedrà presto all’Università di Parma nel prossimo appuntamento in programma: il SQL Saturday #895. 😉

Pubblicato da Marco Breveglieri sul blog Compila Quindi Va e ripubblicabile solo citandone la fonte.

Premessa

Come probabilmente già saprà chi legge questo blog o mi conosce di persona, sono uno sviluppatore software e, come tale, la mia attività quotidiana consiste principalmente nello scrivere codice.

Oltre a scrivere “codice nuovo” per soluzioni software verticalizzate e richieste dai clienti della mia azienda (ABLS Team), mi occupo anche di formazione ma soprattutto di consulenza e sviluppo in outsourcing.

In breve, scrivo anche “codice conto terzi”, coadiuvando altri team di sviluppo e aiutandoli come posso nella realizzazione del proprio software, implementando nuove soluzioni o – nella maggior parte dei casi – modificando ed estendendo quelle già esistenti.

E’ opinione condivisa tra i programmatori, quasi una legge non scritta, che modificare il codice altrui sia una impresa ardua: di fronte alla richiesta di un cliente di modificare un programma disponendo del codice sorgente, molte software house propongono di riscriverlo da zero piuttosto che mettere mano al lavoro altrui, oppure accettano la proposta a fronte di costi elevati e scarse garanzie.

E’ vero che la riscrittura completa, pur rappresentando la scelta più lunga, complessa e rischiosa, a volte rappresenta una strada obbligata: le tecnologie, le metodologie e gli strumenti nell’ambito dello sviluppo software sono in costante evoluzione, e spesso conviene davvero iniziare da capo, magari perché vecchia di anni, viziata da numerosi interventi e “martellate”, apportate spesso da un numero elevato di persone, tutte differenti tra loro e con competenze ed esperienze variabili, che alla fine portano ad avere un groviglio indistinguibile di istruzioni tale che il software ha la consistenza di un castello di carte: nessuno lo tocchi, altrimenti crolla tutto e non funziona più nulla!

Esiste una alternativa al doversi rassegnare all’idea di rifare tutto? La risposta è sì, e si chiama Refactoring.

Refactoring: non è un gioco da ragazzi

Mi sono ritrovato spesso a ricorrere al Refactoring come unica via per poter manutenere un software esistente. E’ probabile che io sia contro corrente, ma credo si tratti di una pratica fondamentale, talvolta imprescindibile se si deve mettere mano a una porzione di codice composta da centinaia righe, scritte magari in modo poco ortodosso, ovvero senza applicare alcun principio fra quelli globalmente riconosciuti dagli sviluppatori (Design Patterns, principi SOLID, ecc.) o perché semplicemente non vi è alcuno schema concettuale identificabile nella struttura del codice, che come tale appare incomprensibile e quindi immodificabile.

Wikipedia definisce il Refactoring come “una tecnica per modificare la struttura interna di porzioni di codice senza modificare il comportamento esterno”. Spesso è più facile a dirsi che a farsi, perché la tecnica non è esente da rischi, ossia non è così facile apportare le modifiche assicurando che il comportamento del programma non venga alterato, soprattutto quando questo è completamente privo di Unit Test e altri espedienti che consentono di verificare questa condizione.

Come è possibile fare Refactoring al meglio e in modo affidabile? Oltre ad armarsi di tanta pazienza, è necessario anche dotarsi dei tool giusti per farlo. La maggior parte degli ambienti di sviluppo (Visual Studio, Delphi, Eclipse, …) possiede già funzionalità incorporate che consentono di eseguire le operazioni più semplici e immediate, come rinominare una classe o un metodo; nella manutenzione di progetti piuttosto grandi e complessi, questi strumenti risultano tuttavia spesso insufficienti ed è necessario ricorrere a prodotti di terze parti.

Per lo sviluppo su .NET Framework con Visual Studio e C#, ad esempio, ci sono due prodotti di cui non posso più fare a meno: NDepend e ReSharper.

Affronterò ReSharper eventualmente in un articolo separato: per chi non lo conosce, al momento basti sapere che si tratta di un “must have” in grado di offrire numerose funzioni per scrivere codice velocemente, unito a una gamma completa di comandi per rifattorizzare il codice in tutta sicurezza e in modo automatico, risparmiando tempo e ottimizzandone la struttura con la garanzia di non alterare il suo comportamento.

Ci sono però delle domande fondamentali da porsi quando si decide di iniziare col Refactoring di un software:

• Quali sono i punti in cui dobbiamo intervenire?
• Come facciamo a sapere che tipo di fix applicare?
• Come riconosciamo una parte di codice foriera di problemi?
• Come sappiamo se sono state usate al meglio le proprietà del linguaggio di programmazione e del framework?

Sebbene ReSharper fornisca alcune risposte a queste domande, l’esperienza con il tool NDepend è decisamente molto più completa.

NDepend: la soluzione!

Sono venuto a conoscenza di NDepend vedendolo spesso citato in forum online di programmazione e conferenze, così ho pensato di dare un’occhiata al tool e metterlo alla prova.

Dapprima ho visionato l’elenco delle feature sul sito ufficiale e ne sono rimasto sbalordito! Pensando al nome del tool, inizialmente credevo si trattasse di una semplice versione per .NET del noto Dependency Walker, una utility per mostrare le dipendenze di un eseguibile (.exe) o di una libreria (.dll) ma compatibile con il .NET Framework. NDepend è invece molto, molto di più! 😊

Installare il software è molto semplice: basta scaricare il pacchetto del programma in formato ZIP ed estrarlo in una directory del proprio disco locale.

NDepend può essere lanciato nel proprio IDE indipendente (eseguendo il file VisualNDepend.exe) oppure eseguito come estensione direttamente integrata in Visual Studio (previa installazione tramite l’apposito programma che si occupa di tutto).

Dopo aver disbrigato le questioni burocratiche della procedura di registrazione e attivato correttamente la licenza, ho iniziato a sperimentare le funzionalità di NDepend, usando come “cavia da laboratorio” il progetto già esistente di un cliente.

Una volta avviato Visual Studio e caricato la Solution desiderata, l’estensione di NDepend mostra un indicatore nella parte inferiore a destra della barra di stato principale dell’IDE. Questa consente di tenere sotto controllo lo stato di salute del vostro lavoro, condizionato dall’adesione del codice ai canoni fissati dall’analisi effettuata da NDepend, completamente personalizzabile in tutti i suoi parametri.

Primi passi con NDepend

Spostando il mouse sull’indicatore, appare una finestrella popup che consente di creare un nuovo progetto NDepend (o caricare un progetto esistente) da agganciare alla Solution corrente.
Se l’associazione è già stata eseguita in precedenza, il progetto NDepend viene caricato in automatico dall’estensione contestualmente all’apertura della Solution a cui fa riferimento.

Ciascun progetto NDepend contiene tutti i valori delle impostazioni per il tool relativi a una specifica Solution, e consente di salvarli in un file separato da quello della Solution o del Project di Visual Studio.

Tutte le funzionalità di NDepend sono accessibili dal comodo menu integrato dall’estensione di Visual Studio e suddiviso in base all’ambito di ciascuna di esse.

Trattandosi del primo utilizzo, io ho scelto di creare un nuovo progetto NDepend da zero: il tool ha avviato un processo di “Build” della Solution aperta e analizzato il codice compilato, visualizzando un report in formato HTML al termine della procedura. All’interno del report troviamo una sintesi dei risultati delle analisi che il software è in grado di eseguire, mostrando una finestra di dialogo per la scelta del passo successivo da compiere.

Nel mio caso, ho scelto di proseguire mostrando la Dashboard del progetto: si tratta di uno strumento molto comodo per tenere sotto controllo tutte le informazioni che il tool è in grado di estrarre, mantenere e storicizzare in merito alla Solution associata.

Ad esempio, vengono indicati il numero di assembly generati dalla soluzione, il conteggio dei namespace, dei tipi, delle classi e dei metodi al loro interno, il numero complessivo di file sorgente, delle righe di codice sorgente ivi comprese quelle che contengono commenti, con una indicazione del loro rapporto percentuale rispetto alle istruzioni vere e proprie.

Personalmente trovo utili in modo particolare gli indici che mostrano la complessità massima dei metodi (a tal proposito, leggi il mio articolo sulla Cyclomatic Complexity) e la stima del cosiddetto “debito tecnico”, ossia la valutazione del costo implicito (espresso in termini di tempo) derivante dalla necessità di rimaneggiare il codice scritto a causa dell’adozione di una soluzione più semplice e sbrigativa, quindi limitata, rispetto a quella che invece rappresenta un approccio migliore e con maggiore manutenibilità.

La Dashboard mostra infine un prospetto delle regole violate e warning che inficiano la qualità del codice sorgente, aggregate e riepilogate in base a diversi criteri, per tipologia e per gravità.

Molto interessanti sono i grafici che mostrano il trend di variazione delle misurazioni effettuate. NDepend è in grado di fornire questa informazione in quanto a ogni build, in modo manuale o automatico, tutti i valori vengono ricalcolati eseguendo una nuova analisi, ma conservando una fotografia delle situazioni precedenti: in questo modo è possibile tenere sotto controllo l’andamento complessivo del progetto, i benefici prodotti dalle modifiche eventualmente apportate e l’evoluzione generale nel corso del tempo.

La Dashboard può essere personalizzata a proprio piacimento, togliendo i riquadri che non interessano o aggiungendone di nuovi: tutte le scelte operate vengono salvate in modo persistente all’interno del file di progetto di NDepend.

Riguardo l’identificazione delle regole violate all’interno del codice sorgente, NDepend fornisce un motore di analisi sofisticato e completamente personalizzabile. Da tempo cercavo uno strumento che fosse simile al famigerato FxCop di Microsoft, ma in grado di offrire maggiori possibilità di customizzazione, ad esempio “chiudere un occhio” su determinate violazioni del tutto trascurabili, concentrandosi invece su quelle più importanti e con maggiore impatto sul debito tecnico dal punto di vista pratico.

Per ciascuna regola violata, il tool consente di individuare i punti esatti nel codice laddove si verifica il misfatto, in modo da procedere in modo mirato alla risoluzione del problema, rilanciando poi l’analisi del codice e comparando i nuovi risultati con i precedenti.

Nelle schermate riportate, io ho preso come riferimento la violazione della regola “Avoid methods with too many parameters“. Facendo clic sulla regola, si ottiene l’elenco dei metodi che sono affetti dal problema. Facendo nuovamente clic sul singolo elemento, si viene portati nel punto del codice interessato per poter apportare le dovute modifiche. Nel mio caso, ho corretto la firma problematica del metodo sostituendo tutti i parametri – evidentemente troppi – e lasciandone solo uno al loro posto, appartenente a un nuovo tipo di struttura che raggruppa tutti i valori dei parametri al proprio interno, espressi come campi.

Questo è ovviamente solo un esempio dei problemi diagnosticati da NDepend, ma le casistiche supportate sono davvero infinite: da quelle più banali, come l’uso di tipi e membri dichiarati come obsoleti, a quelli più subdoli, come la presenza di un numero troppo elevato di metodi all’interno di una interfaccia (che è un indizio della probabile violazione del principio di Interface Segregation Principle).

Conclusioni

Questo post non ha come obiettivo descrivere tutte le caratteristiche complete di NDepend: non sarebbe solo un compito improbo, ma è praticamente impossibile, perché le potenzialità offerte da questo tool sono pressoché infinite, soprattutto nella gestione di progetti software particolarmente grandi e complessi, laddove è necessario imporre un livello elevato di qualità del codice sorgente e continuare a garantirlo nel tempo, con una adesione il più possibile ferrea agli standard di utilizzo sia del Framework sia della piattaforma .NET, sfruttando possibilmente i “coding pattern” riconosciuti che risolvono egregiamente determinati scenari.

Se volete comunque farvi un’idea più approfondita delle capacità di NDepend, c’è una intera playlist di filmati di YouTube che vi mostra nel dettaglio ogni singola feature, con tanto di demo.

Se qualcuno di voi deciderà di mettere alla prova NDepend, sono felice di ricevere i vostri feedback su quali sono le feature che ritenete più interessanti e quali modalità d’impiego innovative avete messo in opera.

Buon Refactoring! 😉

Pubblicato da Marco Breveglieri sul blog Compila Quindi Va e ripubblicabile solo citandone la fonte.

Gli sponsor

L’evento non avrebbe potuto avere luogo senza l’indispensabile apporto dei suoi sponsor: OSItalia e Technolog, assieme a TMS Software, Raize Software, Elevate Software e WPCubed, per finire con DevArt, Steema Software e Gnostice, che per l’occasione hanno offerto promozioni e sconti per l’acquisto dei propri prodotti a tutti i partecipanti.

I seminari

Come ogni anno, l’evento si articola in due giornate: una dedicata a seminari tecnici di approfondimento, l’altra dedicata alla conferenza vera e propria.

Tra le proposte di quest’anno, un corso completo sull’uso di Git a cura di Maurizio Del Magno: una trattazione del noto CVS distribuito, iniziando dalle basi fino alle operazioni più avanzate, rivolto a tutti coloro che guardano con diffidenza a questo sistema ma vorrebbero usarlo con maggiore fiducia e magari contribuire a qualche progetto open source su GitHub.

In alternativa, c’era la possibilità di approfondire i Design Pattern più efficaci con Delphi, tenuto da Primož Gabrijelčič, e i principi del Clean Code, curato da Bogdan Polak.

Meglio qualcosa di più pratico e meno teorico? Marco Mottadelli ha illustrato come inviare notifiche push dalle nostre applicazioni, illustrato da Marco Mottadelli, e la trasformazione in app native di applicazioni Web realizzate con ExtJS, con Luca Minuti.

Non si poteva ovviamente tralasciare l’argomento database, in particolare uno di quelli più utilizzati dagli sviluppatori Delphi: FireBird. Fabio Codebue ha proposto ben 68 modi per ottimizzarlo.

Che dire? I seminari sono sempre una garanzia di qualità, grazie al maggiore tempo per affrontare gli argomenti e la elevata capacità espositiva degli speaker, che hanno preparato il materiale con estrema cura, oserei dire al limite del maniacale. 😊

La conferenza

La giornata del giovedì è invece dedicata alla conferenza, ovvero al momento principale e più atteso dell’evento.

Il trend di partecipazione continua a essere positivo e sempre in crescita, con più di 100 sviluppatori presenti all’edizione di quest’anno!

Questa adesione è un piacevole e confortante segnale del fatto che la community Delphi si mantiene attiva e vitale, soprattutto se si includono nei numeri la partecipazione registrata nelle occasioni appena precedenti, come ITDevCon Spring Edition tenutasi a Roma, e l’inedita Spring4D Conference di Bergamo, della quale potete ascoltare una recensione audio in questo episodio di 🎧 Delphi Podcast.

Ad “aprire le danze” come sempre è Paolo Rossi, Embarcadero MVP e developer di Wintech Italia, con informazioni logistiche sulla conferenza, le statistiche delle passate, presenti e future edizioni, le offerte e i corsi di Wintech, le promo degli sponsor e così via.

Primo a intervenire, e “special guest” dell’evento, Marco Cantù – Product Manager di Delphi – che ha illustrato cosa bolle in pentola nelle cucine di Idera/Embarcadero a seguito del recente rilascio della roadmap aggiornata di Delphi e C++Builder, successivamente approfondita con maggiore dettaglio in questo articolo esteso.

Oltre all’inseguimento costante dei bug e la loro risoluzione per garantire un certo livello qualitativo del prodotto, gli sforzi di Embarcadero si concentreranno sul supporto 64-bit per macOS (ottenibile al momento solo aderendo al programma Beta), su nuovi wizard per RAD Server, su migliorie sulla RTL e piccole evoluzioni del linguaggio per quanto riguarda la versione in cantiere prossima all’uscita (10.3.2).

Più interessanti le novità previste per la versione successiva, la 10.4, che verrà rilasciata più tardi nel corso di questo anno, in particolare il supporto a LSP (Language Server Protocol), uno standard progettato da Microsoft per la comunicazione tra editor di codice, IDE e processi di analisi del codice sorgente, che porterebbe di fatto notevoli miglioramenti all’analisi del codice, grazie alla sua elaborazione “out of process” e non bloccante, con notevoli benefici alle feature di completamento del codice in termini di performance, quindi alle tecnologie Code Insight ed Error Insight che risentono particolarmente del loro attuale affidarsi a tecnologie superate (es. Together e .NET Framework). La tecnologia pare verrà prima integrata per C++, e ciò getterà le basi per supportarla anche sul linguaggio Delphi. Molto atteso e previsto per il tardo 2019 anche il supporto ad Android 64-bit.

Non mi dilungo ulteriormente sull’argomento poiché tutti i dettagli e gli approfondimenti sono presenti nella roadmap e nell’articolo di approfondimento segnalato.

Dopo il primo coffee break, il resto della conferenza è proseguito con diverse sessioni in parallelo, imponendo quindi una scelta sulla “track” da seguire.

Non ho visto la sessione di Primož Gabrijelčič sugli Enumerators ma sono certo sia stata eccezionale e tecnicamente interessante, avendone già avuto una anteprima alla Spring4D Conference di Bergamo. Purtroppo ero impegnato a condurre la mia sessione, “Alexa parla con Delphi!”, dedicata all’integrazione dei famigerati assistenti digitali – come Amazon Echo e Google Home – con un’applicazione realizzata in Delphi capace di ricevere le richieste “distillate” dai servizi vocali (Amazon Alexa, in questo caso) e rispondere nel modo appropriato, aprendo quindi logiche di business delle proprie applicazioni a questi nuovi scenari e dispositivi.
Potete trovare le slide e i sorgenti della mia sessione sul mio account GitHub e sul sito stesso della conferenza.

La mattinata è proseguita con la sessione di Olga Petrova, Sales Engineer di Sencha, che ha realizzato qualche demo live di ExtAngular, ExtReact ed ExtWebComponents, le librerie di componenti compatibili con React, Angular e la piattaforma dei Web Components per integrare i widget di ExtJS all’interno di applicazioni Web realizzate con questi noti framework. Grazie alla recente acquisizione di Sencha da parte di Idera, ci si aspettano nuove possibilità di integrazione tra queste librerie molto interessanti e Delphi.

La giornata è proseguita con ben tre sessioni in parallelo, rendendo ancora più difficile scegliere quale di queste seguire. 😊

Paolo Rossi ha parlato di alcuni tool opensource per Delphi recentemente pubblicati su GitHub, tra cui una libreria per la serializzazione JSON (Delphi Neon) e una per generare la documentazione delle proprie API REST usando lo standard OpenAPI, mutuato da Swagger e reso aperto.

Le altre due sessioni contemporanee hanno invece approfondito il lato database, con Fabio Codebue che ha parlato di replica dei dati con FireBird, una delle nuove feature della release 4.0 del noto database open source, e Sergio Govoni che ha approfondito Query Store, una feature di SQL Server che memorizza i piani di esecuzione delle query allo scopo di analizzare ed estrapolare dati dagli stessi per esigenze di tuning delle prestazioni.

Dopo il pranzo, il resto della giornata si è sviluppata su argomenti ancora più disparati, dall’uso di feature avanzate del linguaggio Delphi con Maurizio Del Magno, all’integrazione di Redis nei propri programmi, il più noto in-memory datastore, mostrato da Luca Minuti, per proseguire con le specifiche di creazione delle cosiddette PWA (Progressive Web Apps), con Paolo Rossi e di nuovo Luca Minuti, e per finire la modernizzazione di progetti VCL spiegata in inglese da Bogdan Polak e la costruzione di plugin crittografici per FireBird a cura di Fabio Codebue.

A mio avviso, si è trattato di una delle più ricche edizioni di sempre, con una vastità e varietà di argomenti e speaker mai viste, a testimonianza del fatto che – qualora fosse necessario ribadirlo – con Delphi è possibile realizzare di tutto, spesso più e meglio di quanto ci si può aspettare. 😉

Arrivederci a novembre con l’edizione padovana del Delphi Day 2019! 🙂

Pubblicato da Marco Breveglieri sul blog Compila Quindi Va e ripubblicabile solo citandone la fonte.

Come di consueto, l’evento è stato diviso in due momenti principali: uno dedicato a seminari di approfondimento, che si è svolto al mattino, l’altro dedicato alla conferenza vera e propria, nel pomeriggio.

L’affluenza è stata molto buona, con sale gremite sia al mattino che al pomeriggio, un successo che non potrà fare altro che piacere agli organizzatori, ovvero ai ragazzi e ragazze dello staff di Wintech Italia.

I seminari

I seminari organizzati al mattino hanno toccato un paio di tematiche fra quelle più attuali, anzi si potrebbe dire addirittura “scottanti”: quello della famigerata Fatturazione Elettronica, e quello dello sviluppo di applicazioni modulari e flessibili.

Fabio Codebue ha curato il seminario sulla tanto detestata (e detestabile) Fatturazione Elettronica, la cui obbligatorietà (salvo rinvii dell’ultimo minuto) è sempre più vicina. La scadenza imminente costringe gli sviluppatori software a correre ai ripari: bisogna trovare in fretta soluzioni per consentire a qualsiasi software che possa emettere fatture di generare il tracciato XML secondo gli standard dettati dall’Agenzia delle Entrate.

Assieme a Fabio abbiamo esplorato la storia, talvolta contraddittoria, delle normative uscite nel corso degli ultimi mesi riguardo la struttura del file XML che contiene i dati della fattura vera e propria e delle interazioni previste con il cosiddetto Sistema di Interscambio (SdI), che dovrebbe smistare le fatture tra i soggetti privati e comunicare l’esito delle operazioni.

Fabio ha poi presentato eInvoice4D, una soluzione open source per la Fatturazione Elettronica scritta in linguaggio Delphi.

La libreria è stata rilasciata nottetempo, appena prima della conferenza. E’ attualmente ospitata su GitHub ed è stata sviluppata dal team di delphiForce, un gruppo di volenterosi programmatori Delphi che ha unito le forze per creare questo progetto in grado di gestire le fasi di generazione del file XML e l’invio a uno o più intermediari diversi (es. Aruba).

L’utilizzo della libreria è estremamente semplice: con poche righe di codice, è possibile creare una nuova Fattura Elettronica in memoria, compilarla con dati di esempio o con i dati reali presi dal proprio applicativo o da un’altra fonte, e generare il file XML, ad esempio per esportarlo su disco. In alternativa, è possibile inviare direttamente la fattura al proprio intermediario, purché questo sia supportato da un apposito provider registrato nella libreria; al momento è disponibile solo il provider per Aruba, ma è ipotizzabile che ben presto la rosa degli intermediari supportati si arricchisca con nuovi fornitori, anzi il team stesso invita a partecipare al progetto e a creare nuovi provider a beneficio di tutti.

Il pacchetto comprende inoltre un servizio Windows pronto all’uso (completo di codice) che debitamente configurato (ad esempio, indicando qual è il proprio provider di riferimento) è in grado di monitorare una cartella e procedere all’invio dei file XML contenenti le fatture non appena si presentano: questo permette di ridurre al minimo il codice da scrivere, soprattutto in versioni datate di Delphi, limitandosi a generare il file XML e a salvarlo su disco.

Grazie poi al contributo di altri sviluppatori che hanno collaborato al progetto, il pacchetto si è arricchito di un visualizzatore, e anche il set di icone rappresentanti le fatture, i relativi stati e così via è stato reso disponibile separatamente.

Che cosa volete di più? 😉

Come sempre, mi dispiace non aver potuto seguire il seminario di Maurizio Del Magno e Luca Minuti sullo sviluppo di software che possano accettare di buon grado i cambiamenti, sull’applicazione dei principi SOLID e dei Design Pattern più utili, in breve sulla realizzazione di architetture che siano il più possibile disaccoppiate fra loro allo scopo di aumentarne la manutenibilità e il riuso.

Del resto, purtroppo, non ho la possibilità di sdoppiarmi (anche se pare io abbia maturato quella di… raddoppiare). 😄

La conferenza

Nel pomeriggio, dopo la consueta procedura di registrazione (e il pranzo per chi era presente già dal mattino), i partecipanti hanno preso posto nella sala principale per l’avvio dei lavori della conferenza vera e propria.

Anche il pomeriggio ha visto una presenza cospicua, una sala quasi piena di persone e con un trend di partecipazione sempre in crescita, sintomo della maturità della community e della voglia di partecipare agli eventi che la coinvolgono.

Il rilascio di Delphi Rio e il futuro di Embarcadero

Il giorno appena prima della conferenza è stato rilasciata la nuova versione di RAD Studio (Delphi e C++Builder), ovvero la 10.3, nome in codice “Rio”: non poteva quindi mancare una sessione interamente dedicata alle numerose novità introdotte in questa nuova release.

Prima di questa però, concluse le rituali presentazioni e saluti iniziali, Paolo Rossi ha riepilogato le ultime acquisizioni fatte da Idera, la società a capo di Embarcadero, che nella sua campagna acquisti – oltre alla più nota Sencha – ha fagocitato anche Froala (creatori di un editor JavaScript molto funzionale) e Whole Tomato (che producono un tool di refactoring per linguaggio C++ in Visual Studio). Esiste quindi una possibilità che il know-how di queste realtà porti nuove feature all’interno dei prodotti Embarcadero. Nel frattempo uno dei tool acquisiti dedicato all’amministrazione di database in diversi formati, Aqua Data Studio, è già incluso nella licenza Architect di RAD Studio 10.3 Rio, assieme a una licenza multi-site di RAD Server e una licenza Sencha ExtJS Professional. Sono ottime notizie: il costo relativamente alto dell’edizione Architect trova finalmente una giustificazione rinnovando la propria offerta e includendo prodotti – come ExtJS – che un tempo venivano acquistati separatamente per essere usati in combinazione con Delphi, mentre oggi fanno già parte della stessa famiglia e vengono distribuiti con esso.

L’argomento successivo non poteva che essere la nuova versione di Delphi appena rilasciata. Delphi Rio 10.3 porta con sé diverse novità che si notano fin da subito, appena l’IDE viene lanciato. Buona parte dell’aspetto grafico è stato ridisegnato per rimuovere alcuni difetti congeniti nello stesso, come doppi bordi, colori di primo piano e di sfondo poco evidenti, toolbar che fluttuano in modo disordinato o che contengono pulsanti che vanno a capo lasciando ampi spazi vuoti, altezze disomogenee e così via. Tutto l’ambiente di lavoro ha quindi subito un re-design, con finestre di dialogo migliorate e filtri incrementali per cercare le opzioni e gli elementi al loro interno.

Anche il linguaggio Delphi è stato esteso, forse con una delle possibilità più insolite per il linguaggio Pascal: la possibilità di dichiarare variabili inline, ovvero all’interno del corpo di procedure, funzioni e metodi, e all’interno di blocchi, limitando la loro visibilità a quell’ambito e senza la necessità di dichiarare tutte le variabili esclusivamente nell’apposita sezione a cui siamo abituati. Si può inoltre usare la Type Inference: non c’è bisogno di indicare esplicitamente il tipo della variabile, poiché questo viene determinato automaticamente in base al valore dell’assegnazione.

Sono state inoltre migliorate le performance di alcune classi e routine della RTL, i cui effetti sono visibili nel lancio e nell’uso dell’ambiente di sviluppo oltreché a run time; la parte dei LiveBindings ha subito delle velocizzazioni, rendendo più veloce l’aggiornamento della visualizzazione dei bindings all’interno del Live Designer.

I compilatori ora includono il supporto per le nuove piattaforme mobile iOS 12 e Android 9, assieme a nuove funzionalità che sfruttano le API di Windows 10.

Altre novità di Delphi 10.3 Rio sono riportate nella pagina del prodotto, oltre che nella documentazione (anch’essa rivisitata con un nuovo tema grafico).

Q&A con Marco Cantù

Dopo l’irrinunciabile pausa del coffee break, la platea ha potuto bombardare di domande Marco Cantù, Product Manager di Delphi presso Embarcadero, collegato da remoto.

Selezionando le domande e le risposte più interessanti, è emerso come il team sia impegnato con priorità alta sullo sviluppo del compilatore Mac a 64 bit, molto richiesto.

Qualcuno ha chiesto notizie sui piani per un IDE a 64 bit: Marco ha risposto che al momento non è previsto (del resto, lo stesso Visual Studio è a 32 bit) ma è possibile che vengano portate a 64 bit alcune parti dello stesso (es. compilatore, analisi del codice, ecc.) che verranno scritti per questa architettura laddove porta un effettivo beneficio.

Un po’ di lamentele (giustificate) sono state espresse sui difetti congeniti di LiveBindings: Marco ha confermato che si sta valutando una sua completa re-ingegnerizzazione, piuttosto che l’apporto di pochi e semplici ritocchi. Delphi Rio include comunque già diverse migliorie che riguardano questa tecnologia, segno che l’impegno su questo fronte c’è.

Sono seguiti poi un paio di demo live su altre feature introdotte in Delphi 10.3 Rio: il supporto ai monitor ad alta risoluzione (4K) con l’API di Microsoft PerMonitorV2, l’uso di funzioni che finalmente forniscono valori corretti per le metriche di sistema e che tengono conto delle effettive caratteristiche del monitor in uso, e un demo del nuovo componente VirtualImageList che permette di sostituire la classica “Image List” con una lista di immagini virtuali, ossia generate dinamicamente, a partire da una nuova “Image Collection” che permette di salvare immagini in diverse versioni e dimensioni, adatte a essere ridimensionate con la minor perdita di qualità possibile, un difetto che si nota soprattutto quando queste vengono ingrandite.

Riguardo la versione Community di Delphi, rilasciata durante l’estate, essa è stata aggiornata alla versione 10.3: per gli studenti, gli hobbisti e i curiosi è possibile quindi scaricare una versione completamente gratuita di Delphi, con le stesse feature dell’edizione Professional e con tutte le novità introdotte in Rio.

PWA con Delphi ed ExtJS

Nella sessione seguente, Luca Minuti ha mostrato il demo di una Progressive Web App (PWA) realizzata con ExtJS e Delphi.

Le PWA sono una nuova tipologia di applicazioni Web su cui Google sta spingendo particolarmente, grazie al supporto offerto dal browser Chrome sia su dispositivi mobile che su desktop (ma gli altri browser si stanno gradualmente adeguando).

Per poter essere definite tali, le PWA devono poter offrire un set di caratteristiche particolari: innanzitutto, devono utilizzare la rete senza fare mai comparire la pagina di connessione assente grazie al lavoro svolto da un “service worker”, una sorta di thread in background che esegue in parallelo, scritto in JavaScript, che contiene il codice vero e proprio di gestione dell’applicazione; esso intercetta le chiamate provenienti dall’interfaccia utente, realizzata con i classici HTML e CSS, e gestisce le chiamate per il recupero dei dati, che possono essere scaricati dal server o prelevati dalla cache. Le PWA sono talvolta installabili sul device o sul desktop, vengono avviate in tempi brevissimi, sono performanti, immersive e coinvolgenti; in breve, mimano quasi alla perfezione il comportamento di un’applicazione nativa.

Un altro elemento fondamentale delle PWA è il cosiddetto “manifest”: un file che specifica le caratteristiche dell’applicazione, come il titolo da attribuire, una descrizione, una icona che la contraddistingue, i colori scelti per la barra degli indirizzi (che può essere anche nascosta), i colori per lo sfondo e per il primo piano; in breve, si tratta di un file di configurazione contenente elementi standard e riconosciuti dal browser di turno che forniscono informazioni sull’applicazione e permettono di personalizzare l’esperienza utente.

Si da il caso che ExtJS contenga un template in grado di generare automaticamente un file manifest.json valido e widget già disponibili che, essendo responsive, sono perfettamente adatti a sviluppare una PWA.

Il codice dell’applicazione è scritto in JavaScript, mentre Delphi ha il ruolo di contenere la business logic, fornire eventualmente una Web API invocabile (usando una delle tante librerie disponibili, anche di terze parti, oppure lo stesso RAD Server distribuito con Delphi) e i file statici delle risorse (pagine HTML, fogli di stile, script, immagini, ecc.) che vengono memorizzati nella cache del browser per consentire alla PWA di avviarsi istantaneamente.

Il termine PWA e le specifiche che sottintende sono ancora in fase di definizione e in continua evoluzione, ma è senz’altro una tecnologia da tenere d’occhio per la rapidità con cui si trasforma una applicazione Web in una app mobile (o un app desktop) molto simile a quelle native e ben integrata nell’ambiente operativo.

Delphi Performance Diagnostic

I tempi stretti accumulati nel corso della giornata hanno rubato un po’ di spazio alla sessione di Paolo Rossi sulla diagnostica delle performance delle proprie applicazioni scritte in Delphi.

L’obiettivo della sessione (a mio avviso comunque perfettamente raggiunto) era quello di sensibilizzare gli sviluppatori sull’importanza di misurare il proprio codice e le sue tempistiche di esecuzione: molto spesso si parla di rendere una routine più veloce o più performante, ma in assenza di strumenti che assicurino il “timing” di queste procedure, è impossibile rilevare se una modifica – ad esempio – ha incrementato o diminuito l’efficienza dell’algoritmo o la velocità della procedura stessa.

Oltre alla misura delle prestazioni, un altro suggerimento molto valido è stato quello di registrare e salvare i risultati ottenuti in un archivio permanente, ad esempio in un database; salvando questi dati a ogni modifica, è possibile determinare con maggiore precisione il momento in cui può aver avuto inizio l’eventuale degrado delle performance monitorate, e identificarne quindi la causa in modo mirato.

Ovviamente, per misurare le prestazioni in modo efficace, è necessario utilizzare lo strumento adeguato in base alle esigenze: se dobbiamo calcolare il tempo di esecuzione di una procedura che impiega giorni, una banale differenza tra l’ora corrente e quella di inizio può restituire un time stamp con una precisione sufficiente, poiché senz’altro i millisecondi non sono significativi; per quantificare tempistiche molto più ristrette, potrebbe essere utile ricorrere alla funzione QueryPerformanceCounter() oppure usare la classe TStopWatch presente in Delphi all’interno della unit Diagnostics.

Per un maggiore approfondimento di questa tematica e delle altre trattate durante i seminari e la conferenza, potete scaricare slide e materiale dal sito ufficiale del Delphi Day.

Conclusioni e saluti

La conferenza si è conclusa con l’estrazione di alcuni premi gentilmente offerti dagli sponsor e con il consueto arrivederci al prossimo evento.

Di certo, ce n’è uno a cui non è possibile mancare: la prima conferenza dedicata alla libreria Spring4D, utilizzata da molti sviluppatori Delphi, che si terrà in Italia nell’aprile 2019 e che ha già un sito dedicato da consultare per maggiori informazioni e per registrarvi in anteprima.

Per tutti inoltre c’è l’appuntamento annuale con la “big conference” online organizzata da Embarcadero, CodeRage, ai nastri di partenza nel momento in cui scrivo.

Detto questo, non mi resta che augurare buona programmazione con Delphi Rio e al prossimo Delphi Day! 👌

Pubblicato da Marco Breveglieri sul blog Compila Quindi Va e ripubblicabile solo citandone la fonte.

Già da qualche edizione, come di consueto, la conferenza si terrà presso la sede di bitTime Professionals, con due track parallele di sessioni ricche di contenuti e che avranno luogo nelle ormai classiche sale “Kirk” e “Spock”. 🖖

Le mie sessioni

Alla conferenza ci sarò anche io e, anche per questa edizione, annoierò i presenti con due sessioni, di cui vi riporto qui di seguito titolo e descrizione. 😊

Actor Model: multithreading e micro services resi semplici

Oggi siamo circondati da CPU multicore con prestazioni stratosferiche, ma gran parte di questa potenza non viene sfruttata dalle nostre applicazioni, e la causa principale è da ricercarsi spesso nelle difficili problematiche della programmazione multithreading: la gestione delle risorse condivise, il coordinamento tra i diversi thread, l’aggiornamento dell’interfaccia utente e così via, problematiche talmente subdole che, se non gestite correttamente, possono provocare effetti devastanti nell’esecuzione del programma e sono tali da scoraggiare anche lo sviluppatore più esperto.
In questo talk approfondiremo il paradigma “Actor Model”, un pattern che semplifica drasticamente lo sviluppo multithreading alla base di alcuni blasonati framework open source: grazie a questa architettura, vedremo come è possibile “salvare capra e cavoli”: creare applicazioni multithreading ultra-performanti e scalabili mantenendo però il codice semplice, manutenibile, testabile e addirittura pronto per trasformarsi in micro service e volare verso il Cloud.

Progressive Web Apps: costruire le app mobile del futuro con Delphi

Tutti parlano di “Progressive Web App” (PWA): si tratta solo dell’ennesima buzz word del momento, oppure c’è qualcosa di tangibile dietro?
La diffusione di dispositivi mobili è capillare e ha ormai surclassato da tempo laptop e computer tradizionali nell’utilizzo quotidiano. Studi statistici mostrano però come gli utenti siano sempre più riluttanti all’installazione di nuove applicazioni sui propri device, poiché ogni app va mantenuta aggiornata, occupa spazio prezioso, necessita di autorizzazioni specifiche e richiede allo sviluppatore di crearne una versione per ciascuna piattaforma e sistema operativo, con il rischio concreto di perdere una fetta importante di potenziali clienti. Esiste una soluzione?
Sì, creare una Progressive Web App. In questo talk scopriremo cosa sono le PWA e quali sono le caratteristiche che le contraddistinguono, approfondendo i vantaggi che offrono rispetto alle applicazioni tradizionali, e vedremo come costruirle utilizzando Delphi come backend, lo strumento ideale per garantire l’affidabilità e le elevate prestazioni richieste.

Last but not least…

Tutte le informazioni su ITDevCon, come l’agenda completa delle sessioni, i profili degli speaker di questa edizione, le offerte per la registrazione e l’acquisto dei biglietti e tutti i dettagli logistici li potete trovare sul sito ufficiale della conferenza.

Se avete la possibilità di “staccare” due giorni dal lavoro, non perdete l’occasione di partecipare a questo evento, anche se non siete sviluppatori Delphi: la conferenza non è solo talk e keynote, ma è sempre anche buona compagnia, buon cibo, condivisioni tecniche (e non), risate, confronto e scambio di opinioni sulle proprie e altrui esperienze, riflessione sulle nuove tecnologie e le opportunità correlate a esse, spunti per nuove idee e coltivazione di possibili collaborazioni.

Ci vediamo a Roma! 😉

Pubblicato da Marco Breveglieri sul blog Compila Quindi Va e ripubblicabile solo citandone la fonte.