Il concetto di semilavorato software
Il codice “standard”
Qualsiasi programmatore con un minimo di esperienza, può rendersi conto che l’attività di sviluppo di applicazioni presenta un altissimo grado di ripetitività nelle strutture del codice.
Ciò accade in modo particolare nello sviluppo di sistemi informativi, ovvero di quelle applicazioni che si occupano di gestire le basi di dati.
In questi sistemi infatti, la percentuale di codice “standard” è significativamente più alta.
Ad esempio, l’esigenza di gestire in una applicazione un’entità come la “Fattura”, prevede la scrittura di codice per estrarre valori da una o più tabelle del database, per eliminarli, modificarli, inserirli ecc.
Queste procedure non sono molto dissimili da quelle necessarie per gestire un’altra entità come ad esempio il “Cliente”, anzi, il codice da scrivere è praticamente lo stesso; ciò che cambia è soltanto l’insieme dei campi che descrivono l’entità.
Ciò che succede è che spesso il programmatore “sviluppa” con il tempo una propria architettura ripetibile (più o meno valida) che utilizza per gestire tutte le entità del sistema.
Il “modus operandi” tipico è quello di ricorrere abbondantemente al “copia-incolla” per cui, il codice per gestire una nuova entità viene copiato da quello utilizzato per un’altra entità, incollato e opportunamente modificato per gestire anche la nuova.
Inutile soffermarsi sui tipi di problemi generati da questo “stile” di programmazione.
Certo poi esiste sempre l’esigenza di “specializzare” alcune parti di codice in maniera “non standard”; ma secondo statistiche molto attendibili, “nei sistemi informativi, mediamente l’80% delle linee di codice che gestistono una entità può considerarsi standard” ovvero appartenente ad una struttura prestabilita e ripetitiva.
Alla luce di questi fatti, cosa succederebbe se fosse possibile generare automaticamente queste linee di codice standard?
Sicuramente avremmo un significativo abbattimento dei costi.
I “vecchi” sistemi di generazione automatica del codice e le loro grosse limitazioni
I sistemi di generazione del codice non sono una novità nel panorama dello sviluppo software.
Esistono già da diversi anni, in diverse forme e qualità, ma non hanno mai riscosso un grande successo presso gli addetti ai lavori a causa delle loro forti limitazioni.
Queste sono le principali obiezioni che vengono mosse contro questi strumenti, ostacolandone quindi la diffusione:
- Rigidità e non modificabilità dell’architettura del codice generato
Il codice viene generato secondo l’architettura prestabilita dal produttore del generatore.
Questa architettura non è modificabile oppure può essere modificata soltanto in parte e con una certa difficoltà.
La conseguenza è che, chi adotta lo strumento, deve anche “sposare” la filosofia e l’architettura abbracciata dal sistema senza la possibilità di implementare la propria.
- Perdita di eventuali customizzazioni nel caso di ri-generazione del codice
Se, come sempre accade, l’utilizzatore ha la necessità di modificare il codice sorgente generato, una eventuale successiva ri-generazione “schiaccerebbe” tutte le modifiche apportate.
- Costo di acquisizione degli strumenti
Questi strumenti spesso hanno un costo iniziale proibitivo ed una curva di apprendimento tanto più costosa quanto più sono potenti.
- Forte dipendenza dell’utilizzatore degli strumenti dalle strategie del realizzatore
L’adozione di questi strumenti, obbliga l’utilizzatore a subire passivamente le scelte strategiche di chi produce lo strumento, e l’utilizzatore di fatto si trova costretto a produrre il codice implementando le architetture e/o utilizzando le tecnologie fornitegli.
Conclusioni:
In conclusione, questi forti limiti hanno fatto sì che negli anni passati questi strumenti non siano riusciti ad attrarre utilizzatori se non in rari casi.
Di fatto questi generatori sono stati utilizzati solamente per la prototipizzazione rapida; ovvero per la creazione a costo contenuto di prototipi “usa e getta” da fornire ai committenti con l’unico intento di allineare le aspettative tra committente e produttore.
Un “nuovo” sistema di generazione automatica del codice
La buona notizia è che l’evoluzione dell’ingegneria del software e delle tecnologie informatiche degli ultimi anni, ha messo via via a disposizione dei produttori di software nuovi strumenti che consentirebbero di superare i limiti appena visti.
Click & Tweet! “Nel mondo della produzione del software non esiste il concetto di semilavorato inteso come prodotto intermedio della lavorazione”
Ecco un elenco dei fattori che concorrono in modo determinante a questa conquista:
- Nuovi paradigmi di programmazione
Gli approcci DDD (Domain Driven Design) o MDA (Model Driven Architecture) consentono di concentrare l’attenzione del team di sviluppo sul modello di business del sistema, modello che, arricchito da una costellazione di informazioni aggiuntive si presta ottimamente alla generazione automatica del codice.
- Nuovi linguaggi standard per la modellazione del software
Il modello che rappresenta l’applicazione da realizzare può essere descritto nel dettaglio e con la necessaria oggettività attraverso linguaggi standard per la descrizione dei modelli come l’UML. In questo modo il modello può essere condiviso da tutte le figure coinvolte nello sviluppo e soprattutto “interpretato” senza ambiguità da un motore di generazione.
- Nuove tecnologie
La ricerca informatica ha messo a disposizione degli sviluppatori strumenti ad alto contenuto tecnologico come esempio i DSL Tools di Microsoft o il templating T4 (Text Template Trasformation Toolkit).
Grazie a questi strumenti, è possibile definire un proprio modello di architettura software e descriverlo attraverso l’utilizzo di modelli semantici e template di testo.
Il tutto, in modo completamente indipendente dalla tecnologia con la quale il software verrà creato.
- Nuovi costrutti dei linguaggi di programmazione ad oggetti
Alcuni dei linguaggi di programmazione ad oggetti più moderni mettono a disposizione degli architetti del software strumenti ingegneristici come l’ereditarietà, le interfacce, le classi parziali, i metodi virtuali, i tipi generici, ecc.
Queste caratteristiche consentono di irrobustire in modo sensibile le architetture e soprattutto consentono di scrivere meno codice e di maggior qualità.
- Nuove funzionalità degli strumenti di sviluppo
I moderni ambienti di sviluppo come ad esempio Microsoft Visual Studio ed Eclipse, offrono delle interfacce di programmazione che permettono di arricchire l’ambiente di sviluppo integrando strumenti di terze parti.
Conclusioni:
Grazie all’integrazione e alla cooperazione di TUTTE le suddette tecnologie, attualmente è possibile realizzare strumenti di produzione automatica del codice in grado di garantire il superamento di TUTTE le limitazioni dei “vecchi” generatori.
Superamento dei limiti dei “vecchi” generatori
Di seguito sono elencati i principali vantaggi offerti dall’adozione dei nuovi strumenti di generazione.
Come si può notare, vengono superati tutti i limiti dei “vecchi” sistemi, rendendo quindi proficua l’adozione dei nuovi generatori.
- Grande facilità nel definire e modificare l’architettura del codice generato
I modelli architetturali da utilizzare per la generazione del codice sono descritti in file di testo che vengono letti ed interpretati dal generatore. Questi file di testo sono liberamente modificabili.
- Facilità di customizzazione del codice prodotto
Modificando i modelli testuali utilizzati dal motore di generazione si modifica facilmente ogni aspetto del codice prodotto.
- Conservazione di eventuali customizzazioni nel caso di ri-generazione del codice
Sfruttando la potenza dei moderni linguaggi di programmazione, il codice relativo alle customizzazioni, risiede su file diversi e separati che non vengono intaccati in caso di ri-generazione.
- Indipendenza dell’utilizzatore del generatore dalle strategie del realizzatore
Il fatto di disporre della propria architettura e di poterla modificare a piacimento e senza difficoltà consente all’utilizzatore di non legarsi in alcun modo alla tecnologia e alle scelte strategiche di chi realizza il motore di generazione ma adottare le proprie architetture e/o svilupparne di nuove con grande libertà.
Abbattimento dei costi
Poter disporre strumenti di generazione automatica moderni costituisce un vantaggio economico (e quindi strategico) di notevole importanza per qualsiasi azienda.
Per capire come e dove se ne ricavano i maggiori benefici, bisogna “far mente locale” sul processo di genesi di un sistema informatico:
- Nascita della necessità nel business del Committente
- Riconoscimento della necessità da parte del Committente
- Concepimento del sistema nella mente del Committente
- Concepimento del sistema nel team di sviluppo
- Realizzazione del sistema
Nelle situazioni 1,2,3 e 4 esisterebbe la necessità di scavalcare le normali fasi del processo produttivo del software per agevolare lo sviluppo veloce di prototipi in grado di modellare una parte o tutto il sistema allo studio.
I prototipi sono lo strumento ideale per allineare le aspettative del Committente con le idee del team di sviluppo perché rappresentano una base di intesa oggettiva in grado di descrivere con il desiderato grado di fedeltà l’aspetto e le funzionalità di un sistema.
Nei settori produttivi nei quali il rapporto tra costo del prototipo e costo del progetto è giustificato, questa attività di modellazione è spesso abbondantemente sfruttata.
Nel settore informatico purtroppo, questo rapporto tra costi e benefici è stato finora particolarmente sfavorevole.
Ma cosa succederebbe se fosse possibile abbattere il costo di produzione di un prototipo software e il rapporto costi-benefici diventasse favorevole?
Immaginando di poter generare a costo bassissimo tutta la parte “standard” del sistema, potremmo offrire al committente un prototipo che costituisce una valida base di intesa.
Inoltre, poiché eventuali customizzazioni apportate al prototipo non vengono perse con le successive ri-generazioni del codice, ma si affiancano al nucleo standard dell’applicazione, si potrebbe a tutti gli effetti parlare di semilavorati software più che di prototipi.
Ecco i principali vantaggi derivanti dall’adozione di questi strumenti:
- Aiuto nella fase di analisi del sistema
Grazie alla produzione veloce di modelli e prototipi e alla condivisione di modelli grafici standard, il team di analisi può raccogliere e analizzare le specifiche in modo molto più efficace
- Allineamento delle aspettative tra Cliente e team di sviluppo
Grazie all’uso dei prototipi, il team di sviluppo può condividere col committente le proprie idee in modo “non ambiguo” diminuendo drasticamente la possibilità di fraintendimenti e dei conseguenti cambi di specifiche.
- Abbattimento del costo di sviluppo
Se tutto il codice “standard” del prototipo viene prodotto senza alcuno sforzo ed in tempi praticamente nulli, si può immaginare quanto il costo di sviluppo dell’intero sistema ne venga influenzato.
Anni di utilizzo del generatore in produzione hanno dimostrato che è possibile abbattere i costi di realizzazione anche fino al 80%.
- Eliminazione di tutti i bug introdotti nel codice standard
Il codice prodotto dal sistema di generazione è virtualmente esente da bug il che si traduce in un ulteriore risparmio.
- Altri manufatti generabili automaticamente
Inoltre, oltre al codice sorgente, possono essere generati a costo zero una serie di altri manufatti come:
- Database su cui poggia l’applicazione
- Documentazione tecnica in linea
- Documentazione stand alone delle architetture utilizzate (pdf, docx, html, ecc)
- API con documentazione
- Unit test
- Script vari
Conclusioni
Nel mondo della produzione del software non esiste il concetto di semilavorato inteso come prodotto intermedio della lavorazione.
Infatti, solitamente, se anche venisse realizzato un prototipo con i “vecchi” sistemi di generazione, quasi sicuramente il suo codice sorgente non verrebbe utilizzato nella realizzazione del prodotto finale.
Click & Tweet! “L’importanza dei semilavorati software”
Adottando invece gli strumenti sopra descritti, si è in grado di fornire a tutti gli effetti, dei semilavorati software da utilizzare in toto come modelli o prototipi o come base per la realizzazione di sistemi informativi finali.