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.

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.

Delphi Community Edition è qui!

Embarcadero ha finalmente deciso di rilasciare una nuova versione, o meglio una nuova edizione di Delphi rivolta al pubblico di sviluppatori professionale e non, agli hobbisti, agli studenti e in generale a tutti coloro che vogliono utilizzare questo ambiente di sviluppo e il suo elegante linguaggio Pascal-based (o imparare a farlo).

Delphi Community Edition è scaricabile gratuitamente e, al contrario dei suoi predecessori, ha tutte le feature della versione professionale più completa.

All’inizio fu “Starter”…

Il rilascio di edizioni gratuite di Delphi non è una novità: Embarcadero rende disponibile già da diverso tempo una versione di Delphi free ma limitata, con nome Delphi Starter Edition e rivolta a coloro che muovono i primi passi con il linguaggio o vogliono utilizzare l’ambiente per costruire semplici app per piattaforma Windows, saggiando la bontà della libreria più matura per questo sistema operativo, ovvero la VCL (Visual Component Library), aggiornata per supportare le ultime novità introdotte in Windows 10, la versione dell’OS di Microsoft che a maggio aveva già raggiunto 500 milioni di dispositivi.

Questa versione tuttavia presentava diverse limitazioni: non era possibile utilizzare l’innovativa libreria FireMonkey (per applicazioni business 2D/3D), sviluppare per Mac OS e nemmeno per le piattaforme mobile Android e iOS; in aggiunta, molti strumenti dell’ambiente di sviluppo per la scrittura veloce del codice non erano disponibili, così come limitata era la connettività ai database, mancava il codice sorgente e così via.

In breve, l’edizione Starter era senz’altro meglio di niente, ma mancava di tutte quelle peculiarità che rendono Delphi l’ambiente appetibile che è in realtà, e questo era motivo di dispiacere per molti sviluppatori, compresi quelli paganti.

L’unico vero modo di saggiare le reali capacità del prodotto era quello di scaricarsi una versione trial, con tutte le funzionalità ma con la “spada di Damocle” del ridotto tempo a disposizione per provarle. Si sa, l’aspetto psicologico ha una sua importanza. Basti pensare che oggi la parola “trial” non si usa quasi più: meglio usare Free e invitare poi al passaggio alla versione Pro una volta ingolosito l’utente.

Quali sono le feature di Delphi Community?

Delphi Community Edition non è una vecchia Starter Edition a cui è stato cambiato il nome, ma rappresenta un notevole passo avanti rispetto alle versioni gratuite rilasciate in precedenza.

Si potrebbe sinteticamente definire come una versione Professional in tutto e per tutto, limitata nella licenza solamente nelle dimensioni e volumi di introiti dell’azienda, della persona o dell’associazione che ne fa uso: ogni sviluppatore individuale o azienda (fino a un massimo di 5 sviluppatori) può usare la Community Edition fino a quando le revenue sono inferiori a 5.000 USD.

Come indicato nella Feature Matrix del prodotto, scaricabile in formato PDF, Delphi Community Edition ha le stesse caratteristiche dell’edizione Professional.

Delphi Community Edition supporta le piattaforme desktop Windows e Mac OS, e le piattaforme mobile iOS e Android. A differenza della precedente Starter, Delphi CE consente l’uso della libreria FireMonkey (oltre alla VCL), inclusi tutti gli strumenti di FireUI a supporto dello sviluppo cross-platform e multi-device (es. live preview sui device), a cui si aggiunge l’IDE con tutte le feature a oggi disponibili, l’accesso a database locali con la libreria FireDAC e il database embedded per mobile IBLite scaricabile tramite il package manager GetIt.

E’ inoltre presente anche il codice sorgente delle librerie Delphi principali (RTL, VCL e FMX), utile quando si vuole dare una sbirciata all’implementazione delle classi per estendere una architettura, replicare un pattern oppure aggirare un bug noto.

E sei hai bisogno di aiuto, nessun problema: anche per Delphi Community Edition è stata predisposta la documentazione ufficiale online, che affianca quella delle edizioni più complete.

Quali sono le limitazioni?

Quali sono le limitazioni della licenza Community rispetto a quelle a pagamento, ad esempio quella più vicina ovvero la Professional?

Come già detto, la restrizione principale riguarda il numero di sviluppatori e il volume di affari dell’azienda che ne fa uso.

La licenza Community è inoltre sottoposta a un termine temporale di 1 anno, che Embarcadero ha promesso di estendere o che ipoteticamente si presume potrà essere rinnovato con l’arrivo di nuovi aggiornamenti.

A questo si aggiunge l’impossibilità di accedere alle versioni precedenti di Delphi, una facoltà concessa a coloro che hanno una Subscription attiva, che possono invece installare versioni più vecchie così come accedere alle versioni future rilasciate, agli aggiornamenti del prodotto e ai vari hot fix.

E’ fatto inoltre divieto (benché sia difficile da verificare) di modificare il codice sorgente incluso nel prodotto.

La licenza di Delphi CE restringe a un massimo di 5 le istanze eseguibili in rete: per esigenze di training massivo è quindi necessario ricorrere all’Academic Program di Embarcadero, che rimane attivo e disponibile.

Conclusioni

Cosa dire di più sul rilascio di Delphi Community Edition? Si tratta di una iniziativa eccezionale, doverosa, estremamente interessante e che sono certo avrà effetti positivi nella diffusione di Delphi come linguaggio e come prodotto, ora che è possibile utilizzarlo liberamente, soprattutto dai neofiti, incrementando il numero di sviluppatori della community.

Ha ragione chi considera l’iniziativa un pochino tardiva (per usare un eufemismo) rispetto alle scelte analoghe della concorrenza. Microsoft – per citare un esempio – rilascia
Visual Studio Community già da diversi anni. Occorre tuttavia tenere a mente che Visual Studio non è il “core business” di Microsoft, ma uno strumento per incentivare l’adozione delle tecnologie su cui Redmond conta (e guadagna) veramente, ossia Windows, Azure, SQL Server e così via. Embarcadero invece produce essenzialmente strumenti di sviluppo, quindi rilasciare gratuitamente il proprio prodotto commerciale è senz’altro una manovra da eseguire con cautela.

A mio avviso, soprattutto per chi – come me – si occupa anche di formazione oltreché di sviluppo, oggi è indispensabile poter disporre di una versione gratuita del prodotto, da fare installare al cliente e da far provare in tutte le sue sfaccettature, passando poi a una versione a pagamento nel momento in cui lo strumento diventa essenziale per
la vita dei progetti software. L’offerta di Delphi Community Edition non potrà che essere un vantaggio in questo ambito.

Grazie al rilascio della Community Edition, Delphi finalmente è accessibile con pochi clic a un ampio pubblico di interessati e possibili adopters. Studenti e universitari finalmente possono scaricare e usare Delphi senza dover compilare noiosa documentazione per ottenere una licenza gratuita. Ciascuno sviluppatore Delphi può usare la versione a cui è abituato anche a casa, per formarsi o costruire le proprie utility personali, senza dover “rubare” una licenza alla propria azienda. 😊 Se sei un appassionato di Internet of Things, puoi costruire da subito i tuoi prototipi realizzando client per tutte le piattaforme conosciute in pochi minuti. E ancora, puoi partecipare al tuo Programmer User Group preferito o alla Coding Gym più vicina e risolvere gli esercizi usando (e facendo usare) Delphi come tool di sviluppo. Puoi irrompere nell’evento dedicato a startup, hacking e simili sviluppando la tua soluzione mobile in pochi istanti sbaragliando i vari X-Coder e Xamariner. 😜

Se sei uno sviluppatore curioso, non c’è momento migliore per iniziare a utilizzare Delphi. C’è addirittura un libro gratuito che puoi scaricare per muovere i primi passi. Se lo conosci già, ora puoi farlo conoscere anche ad altri e allargare la tua community.

Long live to Delphi! 🖖

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

Ma cosa si intende con questo termine? A prima vista è facile pensare che si tratti di una nuova buzz word in voga al momento, ma in realtà la definizione nasconde molto di più.

Che cos’è il Clean Code?

Posso rassicurarvi sul fatto che Clean Code non è un nuovo marchio di fabbrica dietro il quale si nasconde un capitolato di rigide norme sulle quali non si può transigere pena la perdita del “bollino di qualità” o di una qualsivoglia certificazione ISO.

Tutto nasce dal libro di Robert “Uncle Bob” Martins, Clean-Code: A Handbook of Agile Software Craftsmanship, la cui prima pubblicazione risale al 2008. Sebbene il libro sia in circolazione già da qualche anno, sento parlare pochissimo di questa tematica, che invece – a mio avviso – è estremamente importante e rappresenta un must have, o meglio un must know per chiunque voglia definirsi uno sviluppatore professionista.

Il libro contiene consigli e suggerimenti che aiutano lo sviluppatore a scrivere codice pulito, ovvero codice che risulti chiaro e leggibile, e di conseguenza facilmente mantenibile, sia da altri sviluppatori sia dal “se stesso” del futuro, che ne sarà molto grato. Come direbbe Marco Montemagno, «That’s it!». 🙂

Uncle Bob espone in modo chiaro le pratiche da seguire nella scrittura del codice, e anche le trappole da evitare, fornendo anche numerosi esempi di codice a corredo, scritti in linguaggio Java e fondamentali per fissare i concetti. Se utilizzate un linguaggio di programmazione differente, non temete: gli esempi saranno comprensibili comunque senza alcuna difficoltà.

Io la considero una lettura imprescindibile, alla pari del celebre Design Patterns: Elements of Reusable Object-Oriented Software della mitica Gang of Four, e anche un bagaglio culturale indispensabile, come lo sono i principi SOLID o la misurazione e limitazione della complessità intrinseca del codice espressa dalla Cyclomatic Complexity.

I principi in breve

Gli argomenti trattati dal volume sono molteplici e affrontano diversi ambiti della scrittura del codice. Si inizia dalla valutazione del costo intrinseco che le software house sostengono per la manutenzione di codice confusionale, o per riscrivere progetti “nati male” che finiscono inesorabilmente per diventare una nuova Big Ball of Mud.

Si prosegue con le regole di buona condotta per scrivere codice che abbia invece un futuro roseo, spaziando dalla scelta di nomi corretti per gli identificatori, che siano intelligibili e ricercabili, alla dimensione e struttura dei metodi, al numero di azioni che compiono, fino al numero ideale di parametri che dovrebbero avere. Si passa poi alla scrittura di commenti che siano efficaci, alla corretta gestione (e generazione) degli errori durante l’esecuzione e così via. Si termina infine con l’approccio giusto per suddividere i contesti applicativi che influiscono direttamente sull’organizzazione dei moduli software.

Mi fermo qui, inutile spendere altre parole: la gamma di problematiche affrontate dal testo sono così estese che qualunque sintesi non le rende giustizia.

Parliamone assieme…

Se siete interessati all’argomento, ne parlerò (in modo approfondito) nel seminario che si terrà a Piacenza il prossimo 6 giugno, in occasione del Delphi Day 2018.

Potete partecipare seguendo il link, anche se utilizzate un linguaggio differente: sebbene gli esempi siano scritti ovviamente in Delphi, i concetti che rappresentano la parte più sostanziosa saranno esposti in modo comprensibile a chiunque.

Mi raccomando quindi… da oggi, fate risplendere il vostro codice rendendolo pulito, e anche profumato! 😜

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

Ebbene sì, hai letto bene: anche il codice sorgente potrebbe avere problemi di trigliceridi. 🙂

Se anche tu sviluppi software come me, ti sarà senz’altro capitato di avere a che fare con il cosiddetto Spaghetti Code: è un termine usato per indicare quel tipo di codice che diviene incomprensibile poiché pieno zeppo di condizioni, cicli, salti e rimandi, a tal punto da sembrare una palla appiccicosa di spaghetti stracotti come quelli delle peggiori mense aziendali.

La programmazione a oggetti (OOP) ci viene in aiuto consentendoci di strutturare meglio il codice, magari suddividendolo in layer, ovvero strati impermeabili ciascuno dedicato a una funzionalità specifica. Con diligenza, si creano livelli su livelli, ciascuno con singola responsabilità, fino a quando il numero di strati non diventa tale per cui gli spaghetti si trasformano e assumono la forma di una gigantesca lasagna, ed ecco a voi il Lasagna Code.

Se cerchiamo un compromesso tra i due, possiamo scrivere famiglie di classi finalizzate a un particolare scopo e cercare di farle dialogare tra loro: è il Ravioli Code, ma non è un compito facile stabilire in seguito le relazioni tra queste famiglie. Se poi si adottano anche tecnologie e linguaggi di programmazione diversi, ecco che ci troviamo allora con un Maccaroni Code.

Tutto questo parlare di pasta mi ha fatto venire una gran fame, ma anche sorgere una domanda: non c’è uno strumento rapido ed efficace per poter misurare quanto “fa male” alla nostra salute il codice che siamo scrivendo?

Cyclomatic Complexity

Quando ho letto questo termine la prima volta, ho pensato «che diamine è questa roba?». Se vi capiterà di leggere qualcosa sul Clean Code oppure sui principi SOLID, troverete un sacco di termini simpaticamente complicati che, in realtà, nella maggior parte dei casi si riferiscono a concetti semplici e alla portata di chiunque. La Complessità Ciclomatica non fa eccezione, sebbene sembri il titolo di una puntata di The Big Bang Theory.

Ma quindi di cosa si tratta? Niente paura, non ci metteremo di sicuro a enunciare e analizzare formule complesse, anche perché ai tempi delle superiori io avevo 4 in matematica: immaginatela come un indice, un punteggio che viene dato al vostro codice, e tante più sono le strade che il vostro codice può percorrere durante l’esecuzione, maggiore è il valore attribuito a questo indice.

Ad esempio, se abbiamo un codice fatto solamente di istruzioni di assegnazione, o semplici chiamate ad altri metodi (o procedure, o funzioni che siano), il valore sarà quello più basso, ovvero 1 (uno). Se introduciamo una istruzione if, ecco che stiamo creando un “bivio”, ovvero due strade distinte che si possono intraprendere potenzialmente, e il valore aumenta quindi di due punti passando a un totale di tre. E se introduciamo uno switch? Ecco che l’indice della complessità incrementerà di una unità per ogni alternativa che introdurremo all’interno del costrutto. Lo stesso vale per cicli for. In conclusione, più sono i cammini indipendenti che il nostro software potrà percorrere, maggiore sarà il valore della complessità ciclomatica.

Possiamo quindi dire che la Cyclomatic Complexity è un po’ come il colesterolo nel codice: non si può azzerare, ma più il valore è basso meglio è, e bisogna sforzarsi di mantenerlo tale.

Quali sono i rischi?

In genere, i metodi con indice di complessità elevato tendono a essere eccessivamente lunghi, con molteplici righe che potrebbero essere isolate in metodi distinti, poi hanno una incidenza negativa sulla leggibilità e numerose variabili che sottraggono tante scelte dalla rosa dei nomi intelligibili da utilizzare. Insomma, se il software non può rischiare l’infarto, lo sviluppatore che dovrà manutenere quel codice sì.

Per coloro poi che praticano il salutare sport dello Unit Testing, la faccenda si complica: più sono le vie percorribili dal software, maggiore è la quantità di test da scrivere per coprirle tutte in modo da verificare tutte le possibili condizioni.

Misurare la complessità

Il primo passo per ridurre la complessità del codice è dotarsi degli strumenti appropriati per poterla “diagnosticare”. Non serve lo stetoscopio, né gli esami del sangue, ma è sufficiente controllare che l’ambiente di sviluppo in uso possa misurare la cyclomatic complexity del codice. Vediamone alcuni come esempio.

RAD Studio, l’IDE prodotto da Embarcadero per lo sviluppo con Delphi e C++Builder, include strumenti per l’analisi del codice e la visualizzazione di diversi parametri, incluso un coefficiente di tossicità dei metodi. Una volta aperto il progetto su cui lavorare, basta selezionare il menu [Project|Method Toxicity Metrics] per richiamare una finestra che mostra istantaneamente gli indici calcolati in base alle metriche disponibili.

Per gli sviluppatori .NET che utilizzano Visual Studio con i linguaggi C# o Visual Basic.NET, suggerisco una estensione di terze parti – CodeMaid – che offre diverse funzionalità interessanti (tutte descritte nel sito ufficiale), inclusa una finestra denominata Spade che mostra i tipi definiti nel file sorgente aperto nell’editor, la loro struttura (campi, metodi, proprietà, ecc.) indicando per ciascun metodo l’indice della Cyclomatic Complexity aggiornato a ogni salvataggio. In alternativa, se siete felici possessori di ReSharper, un tool che non dovrebbe assolutamente mancare in qualsiasi installazione di Visual Studio, potete scaricare una estensione gratuita che calcola la complessità dei metodi e visualizza un warning quando questa supera le soglie di tolleranza prestabilite.

Qualunque sia il tool di sviluppo che state utilizzando, verificate quanto prima l’esistenza di un prodotto o di una estensione (gratuita o a pagamento che sia) in grado di fornirvi questa misura, ancora meglio se in tempo reale e con la possibilità di tenere d’occhio costantemente i valori.

Come “curare” il codice?

Quando il dottore ci diagnostica una complessità elevata nel codice, come possiamo intervenire per ridurla?

Lo slogan sarà pure molto inflazionato, ma anche in questo caso prevenire è meglio che curare: quando si scrive il codice, è necessario monitorare l’indice di complessità e accertarsi che non oltrepassi il limite della dignità. Se ci si accorge che il valore inizia a diventare troppo alto, questo è un chiaro segnale che il codice implementato sta divenendo troppo complesso e intricato ed è necessario quindi eseguire un refactoring per ottimizzarlo o suddividerlo in metodi più piccoli, molto più gestibili e ricollocabili anche in altre strutture, se necessario. Molti tool di refactoring incluso il già citato ReSharper sono dotati di una funzione “Extract Method” per isolare un pezzo di codice all’interno di un metodo lasciando al suo posto la chiamata a quest’ultimo.

E ancora, quando la presenza di uno switch (o di un case del Pascal) fa esplodere il valore dell’indice, è necessario sostituire il costrutto con una implementazione che potrebbe apparire più complessa da realizzare, ad esempio creando un dizionario di associazione tra i valori dello switch e l’implementazione da eseguire, usando funzioni lambda o delegati, oppure sfruttando la programmazione a oggetti e in modo particolare il polimorfismo per delegare a ciascuna sottoclasse derivata la specifica implementazione dei singoli rami logici dello switch.

Conclusioni

Una delle domande che mi viene rivolta più frequentemente è questa: «Come faccio a scrivere codice manutenibile e soprattutto testabile?». Ecco, non esiste specificatamente una qualità che attribuisce in automatico, a qualsiasi porzione di codice, la caratteristica di “testabilità” a prescindere: occorre impegnarsi ed esercitarsi nel tenere innanzitutto sotto controllo le metriche di tossicità del codice e applicare le metodologie adeguate, primi fra tutti i principi SOLID, per ridurla drasticamente equilibrando i fattori di modularità e separazione degli ambiti tra i vari moduli software, e a quel punto il codice apparirà manutenibile e testabile come per magia. 🧙

Sebbene esistano tantissimi prodotti, anche complessi e costosi, in grado di compiere analisi molto approfondite del codice, generando indici e report dettagliati rivolti ai soli esperti, l’obiettivo di questo articolo è quello di sottolineare che esistono anche strumenti e tecniche semplici da usare, globalmente diffusi e immediati nella comprensione che permettono allo sviluppatore di tenere sotto controllo la complessità del codice scritto con poco sforzo, indipendentemente dal proprio livello di esperienza.

E voi, quali sono le strategie e gli accessori che utilizzate per mantenere sano il vostro codice? 😉

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

L’evento si è tenuto anche quest’anno nella sede di bitTime Software a Roma, tra le verdi colline che adornano la città di Frascati, con un tempo metereologico da fare invidia all’estate.

Dopo la parentesi primaverile della Spring Edition è tornata quindi la “sorella maggiore” della conferenza, con due giornate piene di interessanti speech, sia in italiano ma anche in inglese, per non far mancare nulla agli ospiti venuti da fuori Italia, che sono certo avranno gradito parecchio anche le prelibatezze servite nei coffee break e nel pranzo durante il giorno, raggiungendo il top con i piatti della tradizione locale serviti all’agriturismo per cena, inclusi i tipici Saltimbocca alla Romana (che Fabrizio Bitti, CEO di bitTime, ha prontamente tradotto per i non italiani in «Jump in Mouth at the Roman Way»). 😄

Anche questa edizione ha mantenuto lo spirito che la contraddistingue: contenuti tecnici di elevata qualità, a giudicare dai feedback positivi lasciati dai presenti al termine di ogni singolo speech, con una buona dose di humour che non guasta mai.

La caratteristica più apprezzabile di ITDevCon, a mio avviso (e dopo anni di partecipazione come speaker e come attendant posso dirlo) è che non ti lascia mai tornare a casa senza una buona dose di spunti e ispirazioni da cui trarre nuove idee e tecniche per il nostro lavoro. Questo è dovuto al fatto che tutti gli speaker cercano sempre di trasmettere le proprie esperienze, e non solo di raccontarle asetticamente, una tendenza che non sempre si trova negli eventi di questo tipo, a cui si aggiunge l’accoglienza esclusiva dei padroni di casa.

Slide e codice sorgente

Quest’anno ho partecipato come speaker (ormai è una tradizione) proponendo due talk.

Nel primo talk, intitolato ironicamente «Non Aprite Quella Unit!», ho presentato esempi di “codice orrorifico” tratti dalla mia esperienza di “code revision” presso clienti, sia per farsi quattro risate, sia per introdurre l’argomento principale della sessione, ossia la scrittura di “codice pulito” (Clean Code) e i benefici che porta nel team di sviluppo, in termini di chiarezza e manutenibilità del codice, partendo dalle regole più banali e intuibili fino ad arrivare agli accorgimenti più sconosciuti e difficili da attuare.

Nel secondo talk, intitolato «Crea un Information Radiator con Delphi», ho spiegato innanzitutto cosa si intende con questo strano termine: si tratta di un pannello che distribuisce informazioni alle persone nelle vicinanze, collocato e dimensionato affinché sia visibile con facilità. Ne avrete sicuramente visti in aeroporto, per mostrare le informazioni sul volo in partenza, oppure negli autogrill, per diffondere informazioni sul traffico e le ultime notizie. Si tratta di una nuova tendenza, che sta dilagando al punto tale che pure i team di sviluppo li stanno adottando per tenere sotto controllo l’andamento delle attività sui progetti aperti e gestiti con metodologie agili (es. Scrum). Per realizzare il nostro pannello, abbiamo scelto Raspberry Pi 3 come hardware e Delphi (con FireMonkey) per creare un’applicazione Android nativa e ultraveloce (rispetto alle soluzioni più comuni basate su pagine Web a rotazione e browser pesanti).

Potete scaricare i sorgenti dal mio repository su GitHub, assieme alle slide pubblicate nel mio profilo su SlideShare a questi indirizzi:

• Non Aprite Quella Unit! (ovvero scrivere Clean Code in Delphi)
• Creare un Information Radiator con Delphi

Conclusioni

In breve, se non avete mai partecipato o se mancate da qualche anno, non mi farei sfuggire la prossima edizione, magari la Spring se ci sarà. 😉

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

A furor di popolo, come si suol dire, la conferenza europea dedicata a Delphi ITDevCon torna il prossimo venerdì 26 maggio a Roma per una edizione speciale primaverile, in forma ridotta (solo una giornata prima del weekend) e in lingua italiana, ma come sempre molto ricca di argomenti interessanti per gli sviluppatori Delphi.

Affrettatevi ad acquistare i biglietti per partecipare alla conferenza, perché stanno per terminare sia i biglietti che i giorni a disposizione. 🙂

L’agenda completa dell’evento la trovate sul sito ufficiale. Fra i tanti speaker presenti ci sarò anche io con due talk orientati all’integrazione di Delphi con il Web.

Come usare REST API fantastiche e dove trovarle

Nel mondo là fuori c’è un intero universo di Web API interessanti e curiose, tutte da esplorare. Dopo una breve introduzione, utile a fissare bene determinati concetti di base, in questo talk vedremo come è possibile “consumare” queste API con Delphi, costruendo applicazioni client anche molto accattivanti e di sicuro impatto.

Applicazioni Web ultra-performanti con Vue.js e Delphi

Vue.js è una libreria JavaScript per creare interfacce utente estremamente performanti, che può essere introdotta gradualmente nelle vostre applicazioni Web, nel modo meno invasivo possibile. In questo talk vedremo come utilizzare la libreria per costruire passo passo un frontend fino alla sua integrazione con un backend realizzato in Delphi.

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

Ho reso pubblici slide e codice sorgente degli esempi relativi ai talk tenuti alla conferenza ITDevCon 2016 – European Delphi Conference.

Codice sorgente

Il codice sorgente può essere scaricato dalla mia pagina su GitHub, che contiene anche il materiale utilizzato nelle conferenze passate. I sorgenti degli esempi di ITDevCon 2016 li trovate precisamente in questa cartella, che include anche i documenti PDF con le slide.

Per scaricare gli esempi, potete clonare il repository usando il vostro client Git preferito, oppure scaricare lo ZIP del repository con tutti i sorgenti.

Slide

Le slide mostrate durante l’evento le trovate sulla mia pagina SlideShare.

Potete visualizzarle direttamente online e scaricarle a questi link:

• Create Your Bot with Delphi and Telegram
• Web Development with Delphi and React

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

Sono tornato già da qualche giorno dalla “gitarella” a Roma per ITDevCon 2016 (sito ufficiale), la conferenza europea dedicata a Delphi. Ecco qui una breve recensione dell’evento.

Dopo le esperienze di Verona e Milano, quest’anno l’evento si è svolto per la prima volta a Roma, nel quartier generale di bitTime Professionals, gli organizzatori dell’evento: oltre al beneficio del valore tecnico, la conferenza è sempre un’ottima occasione per spostarsi e vedere posti nuovi.

Questa edizione ha visto la partecipazione di una sessantina di persone, un vero “sold out” con la room principale piena: unito al dato di partecipazione del Delphi Day dello scorso giugno, il risultato conferma il desiderio di fare community da parte degli sviluppatori, che è uno degli aspetti di maggiore risalto in questo tipo di eventi, nonché il vivo interesse verso Delphi e le novità che riguardano il prodotto.

Dal punto di vista dei contenuti, non sono mancati gli approfondimenti relativi alle tecnologie assodate ma anche a quelle emergenti.

Si è parlato di sviluppo di applicazioni Web e SPA (Single Page Application), usando le librerie Angular2 e React lato client, ovviamente con backend in Delphi, approfondendo ben due librerie free e Open Source, DelphiMVCFramework e MARS Curiosity, che si affiancano a quelle già disponibili “out of the box” in Delphi.

Non sono mancate le sessioni maggiormente orientate agli “smanettoni”, con un approfondimento di tecniche avanzate per il debugging delle applicazioni e gli “internals” del memory manager FastMM4.

La tematica dell’accesso ai dati non è stato senz’altro trascurata: si è parlato del movimento NoSQL e delle caratteristiche di uno dei database NoSQL più diffusi, MongoDB, per il quale la libreria FireDAC offre un driver già da qualche versione. A questi argomenti si è aggiunto un approfondimento di Firebird 3.0 e delle novità portate dalla nuova versione, assieme a una sessione di tips per incrementarne le performance.

Io ho tenuto uno speech su un argomento particolarmente in voga al momento, ovvero i Bot e il loro possibile impiego nelle proprie soluzioni business, spiegando come realizzarne uno sfruttando la piattaforma messa a disposizione da Telegram, realizzando a titolo di esempio un bot ad hoc per la conferenza, in grado di fornire informazioni sempre aggiornate sulle sessioni e sugli speaker, oltre ad avvisi organizzativi (con una punta di “british humour”).

Ho trovato particolarmente interessanti le sessioni su Arduino e sugli spunti di integrazione con Delphi: basta davvero solo la fantasia per immaginare uno scenario di possibile utilizzo della scheda assieme ai tanti moduli ordinabili in rete per costruire qualcosa di concreto da cui potrebbe scaturire un’interessante idea.

Infine, sono stati molti i tool e le librerie analizzate nel corso dei vari talk, tutti in buona prevalenza gratuiti e open source, in grado di ricoprire la totalità delle problematiche di sviluppo di qualsivoglia tipo di applicazione Delphi.

Il tutto contornato da un’ottima cena e da abbondanti buffet pomeridiani che hanno reso ancora più gustosi i coffee-break di condivisione e chiacchiere con gli altri partecipanti.

Promossa quindi a pieni voti anche questa edizione romana di ITDevCon, per la generosa ospitalità e l’ottima organizzazione, per la quantità e qualità dei contenuti tecnici proposti, per la ricca premiazione e per la simpatia dei partecipanti e dello staff che ci ha gentilmente ospitati.

Arrivederci quindi a presto, si spera, a una nuova edizione di ITDevCon!

Vi pubblico qui di seguito qualche foto e i tweet in diretta.

ITDevCon 2016 – Galleria fotografica

Visualizza la mia galleria fotografica su Google+

ITDevCon 2016 – Tweet live

https://twitter.com/DelphiPodcastIT/status/783923983955689472
https://twitter.com/DelphiPodcastIT/status/783932710607790080

È in corso la sessione più tecnica in assoluto: il coffee break con colazione. Ed è uscito anche il sole! #ITDevCon pic.twitter.com/UcKpGsGpD9

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

Marco Cantù (@marcocantu) parla di cosa "bolle in pentola" nelle cucine di @EmbarcaderoTech e delle novità in arrivo su #Delphi. #ITDevCon pic.twitter.com/Ptj1qto9cm

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

In arrivo con la versione "Godzilla" di Delphi il supporto a Linux per Server e Console application! #ITDevCon https://t.co/7vhR5Rm0EP

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

La libreria VCL rimane ancora oggi la migliore libreria nativa esistente per sviluppo nativo su Windows, versione 10 e precedenti #ITDevCon pic.twitter.com/Gg9V578mEZ

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

Grazie a #FireMonkey puoi creare veloci applicazioni native crossplatform con supporto ai temi delle piattaforme e senza fatica. #ITDevCon pic.twitter.com/h6xuUI1QZc

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

A differenza di altri framework (es. #Xamarin) con #FireMonkey hai decine e decine di componenti #Delphi già pronti all'uso! #ITDevCon pic.twitter.com/EpBFCqkGmi

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

Academic Initiative: #Delphi disponibile gratuitamente per scuole. Per gli sviluppatori non-professional c'è Delphi Starter free! #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

Salvatore Sparacino (@ssparacino) spiega il "movimento" #NoSQL, e quando, come e in quali scenari usare #MongoDB nel suo talk a #ITDevCon. pic.twitter.com/C4ZNp461iJ

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

https://twitter.com/DelphiPodcastIT/status/783960307651805184

La killer feature di #MongoDB è senz'altro quella di essere schema-less: ALTER TABLE non è richiesto per modificare la struttura. #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

Embedding or not embedding? La risposta come sempre è "dipende". Occorre controbilanciare l"embedding con l"uso di "reference". #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

Daniele Teti (@danieleteti) mostra la roadmap di #DMVCFramework con funzionalità presenti e quelle attese in futuro. Tanta roba! #ITDevCon pic.twitter.com/yQDbCd64ld

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

#Delphi MVC Framework ha tutto: middleware per cross-cutting services, authentication/authorization basic o #JWT, Mustache Views. #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

#DMVCFramework supporta il caching (importante per le performance!) e le Push Notification grazie all'integrazione con #RabbitMQ. #ITDevCon pic.twitter.com/vChwMe1uhn

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

https://twitter.com/DelphiPodcastIT/status/783986274810097665

Esistono infinite espansioni (Shield) per #Arduino: dal video al suono, al GPS, allo storage, al networking, combinabili a piacere #ITDevCon pic.twitter.com/0pKVtX0kWA

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

https://twitter.com/DelphiPodcastIT/status/784015475470655488

Con poche righe di codice e nessuna competenza hardware specifica si crea un'app per accendere LED colorati con #Delphi e #Arduino #ITDevCon pic.twitter.com/vVMu7Aen8P

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

Daniele Spinetti (@Spinettaro) inizia la carrellata dei "sette nani" con TRESTAdapter, un wrapper per servizi REST dichiarativo. #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

Si continua con #LoggerPRO, una libreria di logging su diversi canali e facilmente estensibile creando nuovi "appenders". #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

Con #Firebase4Delphi si parla con la piattaforma BaaS acquisita da Google, #Firebase, per sfruttare il servizio di real time DB. #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

E ancora, Delphi Event Bus (DEB) permette di disaccoppiare "publisher" e "subscriber" all'interno del design dell'applicazione. #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

Delphi Entity Validators (DEV): un #framework per definire logiche di validazione tramite attributi anche in diversi contesti. #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

#TestInsight è un tool indispensabile per gestire ed eseguire i test bell'idea di #Delphi sviluppando con metodologia #TDD. #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

#FGX è un set di componenti open source #FireMonkey per lo sviluppo mobile con effetti grafici e feedback visuali aggiuntivi. #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

Victory Fernandes racconta esperienze con #Arduino e casi d'uso avanzato della scheda per supportare scenari più complessi. #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

https://twitter.com/DelphiPodcastIT/status/784059498201772032

Paolo Rossi (@awebguy) spiega tecniche per gestire meglio sorgente (proprio o di terzi) e componenti nelle installazioni Delphi. #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

Per progetti grandi, ma anche piccoli (poiché cresceranno) è necessario dare una struttura sensata alle cartelle su file system. #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

È consigliato sfruttare le variabili d'ambiente per i percorsi delle librerie rendendo "portabili" i progetti tra membri del team. #ITDevCon

— Delphi Podcast (@DelphiPodcastIT) October 6, 2016

#ITDevCon è ripartita! Daniele Spinetti (@Spinettaro) illustra i vantaggi pratici dell'uso di Delphi Event Bus (DEB) in ambito commerciale.

— Delphi Podcast (@DelphiPodcastIT) October 7, 2016

Andrea Magni (@andreamagni82) parla delle funzionalità di #TFrameStand e della consistenza tra le schermate dell'interfaccia (UI). #ITDevCon pic.twitter.com/7FUi39piLq

— Delphi Podcast (@DelphiPodcastIT) October 7, 2016

Daniele Teti mostra le caratteristiche di #Angular2 e come sfruttarlo nella creazione di web app con #Delphi sul backend. #ITDevCon pic.twitter.com/E9yuFMkSYq

— Delphi Podcast (@DelphiPodcastIT) October 7, 2016

Andrea Magni (@andreamagni82) presenta la libreria per creare servizi REST #MARSCuriosity, open source e scaricabile da Git. #ITDevCon pic.twitter.com/fivHLPykd0

— Delphi Podcast (@DelphiPodcastIT) October 7, 2016

È iniziato il talk sull'uso di #Redis come cache per le proprie applicazioni #Delphi. Seguiamo Daniele Teti (@danieleteti)! #ITDevCon pic.twitter.com/s6e3LiHmfZ

— Delphi Podcast (@DelphiPodcastIT) October 7, 2016

Uno degli use case più diffusi di #Redis: cache distribuita per spingere le performance delle applicazioni (anche più istanze). #ITDevCon pic.twitter.com/AeHVlxo2O5

— Delphi Podcast (@DelphiPodcastIT) October 7, 2016

https://twitter.com/DelphiPodcastIT/status/784421862243725313

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