Software Design Techniques
Corso tenuto alla FILS, nella sezione in lingua inglese, al quarto anno, primo semestre. Prosegue il corso Software Development Methods e sposta l’accento dall’analisi e dalla modellazione alla progettazione vera e propria dei sistemi software, alle decisioni architetturali e alle tecniche di strutturazione delle grandi applicazioni.
Riferimenti essenziali
- Istituzione: Università POLITEHNICA di Bucarest
- Facoltà: FILS – Facoltà di Ingegneria in Lingue Straniere
- Specializzazione: Information Engineering
- Anno / semestre: quarto anno, primo semestre
- Lingua di insegnamento: inglese
- Titolo ufficiale: Software Design Techniques
- Docente responsabile: Luca Dan Șerbănați
- Struttura: 2 ore di lezione + 2 ore di laboratorio
- Valutazione: due progetti principali + esame scritto
- Crediti: da verificare
- Prerequisiti: Software Development Methods, Object-Oriented Programming
Il posto del corso nell’evoluzione della mia attività didattica
Questo corso rappresenta una delle forme più mature del modo in cui ho inteso insegnare l’ingegneria del software alla FILS. Se in Software Development Methods l’accento era posto sul processo, sui requisiti, sulla modellazione del dominio e sulla costruzione graduale del modello di analisi, qui l’interesse si sposta sulla progettazione: come si organizza il sistema, come si distribuiscono le responsabilità, come si scelgono le strutture architetturali e come si riutilizzano soluzioni di progettazione convalidate dall’esperienza.
Inoltre, il corso apre esplicitamente la strada ai sistemi distribuiti, al middleware e alle architetture orientate ai servizi; non rimane quindi al livello della progettazione locale orientata agli oggetti, ma passa ai problemi più ampi dei sistemi software enterprise.
Obiettivo del corso
Il corso mira a formare una visione ingegneristica della progettazione software: come passare dai modelli risultanti dall’analisi a strutture implementabili, come separare l’astrazione dall’implementazione, come scegliere stili e pattern adeguati e come progettare sistemi che rimangano modulari, scalabili, manutenibili ed estensibili.
Da questa prospettiva, la disciplina ha un duplice carattere: da una parte, chiarisce i principi teorici della progettazione; dall’altra, obbliga gli studenti ad applicarli concretamente in progetti di dimensioni maggiori rispetto ai consueti esercizi di programmazione.
Profilo del corso
Il materiale del corso lo presenta come un insegnamento di advanced software design, destinato allo sviluppo di sistemi software di grandi dimensioni. L’accento cade sulla relazione tra progettazione orientata agli oggetti, architettura dei sistemi e tecniche di riuso. Il corso supera così il livello di un semplice repertorio di diagrammi UML e cerca di offrire un quadro concettuale coerente per la progettazione di sistemi complessi.
Può essere considerato un ponte tra le discipline di analisi e modellazione, da una parte, e quelle dedicate all’architettura software, ai sistemi distribuiti e all’integrazione delle applicazioni, dall’altra.
Struttura del corso
1. Introduzione al software design
La parte introduttiva discute il posto della progettazione nel ciclo di vita dello sviluppo software, la differenza tra forward engineering e reverse engineering, il ruolo dei modelli nel processo di sviluppo e il carattere architecture-centric dello Unified Process. In quest’area viene chiarita anche la distinzione tra architectural design e object design.
2. Concetti e principi fondamentali di progettazione
Il corso introduce gli strumenti concettuali della progettazione: astrazione, reificazione, deduzione e induzione. Su questa base vengono discussi i moderni principi di progettazione: SOLID, DRY, KISS, YAGNI, nonché l’idea di separation of concerns. Compaiono anche tecniche classiche quali stepwise refinement, livelli di astrazione e progettazione strutturata.
3. Qualità perseguite nella progettazione
Una sezione importante riguarda il vocabolario della qualità ingegneristica: modularità, componentizzazione, riuso, prestazioni, scalabilità, resilienza, tolleranza ai guasti ed elasticità. L’accento cade sul fatto che la progettazione è essenzialmente una negoziazione tra vincoli e qualità desiderate.
4. Dall’analisi alla progettazione
Il corso spiega esplicitamente come il modello di progettazione derivi dal modello di analisi: la relazione tra use-case model, modello del dominio, SSD, contratti delle operazioni e classi di progettazione. Viene sottolineata l’idea della tracciabilità della progettazione rispetto all’analisi e quella di “ridurre la distanza intellettuale” tra il dominio del problema e la struttura software.
5. Riuso e pattern nello sviluppo software
Una componente centrale del corso è dedicata al riuso: non soltanto riuso del codice, ma anche di idee, strutture, comportamenti, esperienza ingegneristica e modelli di soluzione. In questo contesto vengono introdotti i concetti di pattern, stile architetturale, pattern architetturale e architettura specifica di dominio.
6. Assegnazione delle responsabilità
Prima dei pattern GoF propriamente detti, il corso discute i principi fondamentali per l’assegnazione delle responsabilità alle classi: Information Expert, Creator, Low Coupling, High Cohesion e Controller. Essi svolgono il ruolo di criteri generali della progettazione orientata agli oggetti.
7. Pattern fondamentali e creazionali
Vengono trattati pattern fondamentali quali Delegation, Interface, Marker Interface e Proxy, seguiti dai pattern creazionali: Factory Method, Abstract Factory, Builder, Prototype, Singleton e Object Pool.
In questa parte il corso insiste sul disaccoppiamento del client dalle classi concrete, sul controllo del processo di creazione e sul riuso delle strutture per la costruzione di oggetti complessi.
8. Pattern strutturali e comportamentali
Il corso affronta poi pattern strutturali quali Filter, Composite, Adapter, Iterator, Bridge, Facade, Decorator e Virtual Proxy, nonché il repertorio dei pattern comportamentali (Command, Observer, State, Strategy, Template Method, Visitor, Mediator, Interpreter ecc.).
L’obiettivo non è memorizzarli isolatamente, ma comprendere le relazioni tra loro e il modo in cui possono essere combinati nella progettazione di un’applicazione reale.
9. Stili e pattern architetturali
Un’altra sezione importante è dedicata all’architettura software: la differenza tra stile architetturale, pattern architetturale e architettura di riferimento, nonché il loro ruolo nell’organizzazione dei grandi sistemi. Vengono discussi stili quali monolitico, client–server, N-tier, layered, component-based, event-driven, message-passing, SOA, REST, microservices, peer-to-peer e space-based.
Sono presentati anche pattern architetturali quali Broker, Model-View-Controller, Model-View-ViewModel, Microkernel, Plug-ins, CQRS e Ports and Adapters.
10. Sistemi distribuiti, middleware e servizi
Nella parte avanzata, il corso si occupa della progettazione delle applicazioni distribuite: le dimensioni della distribuzione, della concorrenza e della persistenza, i servizi necessari al calcolo distribuito e l’infrastruttura middleware. Vengono introdotte forme di middleware per la comunicazione remota: RPC/RMI, ORB e Message-Oriented Middleware, seguite dal ruolo degli application server.
Il corso passa quindi alle architetture orientate ai servizi, all’approccio SOMA e a un’introduzione alle architetture orientate ai web service.
11. Progetti
Il materiale del corso indica esplicitamente una componente applicativa consistente: esercitazioni pratiche e due importanti progetti di progettazione. Questi miravano non soltanto all’applicazione isolata di alcuni pattern, ma alla loro integrazione in un design coerente, capace di sostenere requisiti funzionali e non funzionali realistici.
Laboratorio e progetto
La componente pratica del corso aveva il compito di trasformare principi e pattern in decisioni effettive di progettazione. Gli studenti dovevano scegliere strutture adeguate, giustificare l’uso di determinati pattern e costruire modelli di collaborazione tra oggetti, sottosistemi e servizi.
I progetti occupavano un posto centrale nella valutazione. Dal materiale recuperato risulta che erano concepiti come veri progetti di design, non come semplici esercizi di codifica: dovevano dimostrare la scelta di uno stile architetturale, di pattern dominanti e di una struttura coerente delle responsabilità.
Bibliografia di base
- Luca Dan Șerbănați, Software Design Techniques, materiale del corso.
- L. D. Șerbănați, Integrating Tools for Software Development, Yourdon Press / Prentice Hall, 1992.
- E. Gamma, R. Helm, R. Johnson, J. Vlissides, Design Patterns.
- G. Booch, J. Rumbaugh, I. Jacobson, The Unified Modeling Language. User Guide.
- M. Fowler, UML Distilled.
- C. Larman, Applying UML and Patterns.
- R. C. Martin, lavori sui principi SOLID.
Significato del corso
Visto retrospettivamente, questo corso segna il passaggio dall’insegnamento della modellazione software all’insegnamento dell’arte di progettare concretamente sistemi complessi. Non tratta più soltanto “come descriviamo” un sistema, ma “come lo organizziamo” affinché resista al cambiamento e possa essere esteso, distribuito e integrato.
In questo senso, occupa una posizione di collegamento tra l’analisi e la modellazione apprese in precedenza e le discipline dedicate all’architettura software, ai sistemi distribuiti e all’integrazione. Cercava di abituare gli studenti all’idea che la progettazione non è una semplice continuazione dell’analisi, ma un’attività distinta nella quale intervengono compromessi, vincoli, scelte tecnologiche e forme di riuso.