DiarioDelleLezioni < LDPMat

---+++ <font color="#CC0000" size="+3">Diario delle Lezioni 2020-21</font>

*Martedì 29 settembre 2020 - Lezione 1*
<blockquote>
<b>Introduzione</b>
Algoritmi e programmi: la rilevanza dello studio dei Linguaggi di Programmazione.<br />
Analisi di problemi del C che rendono difficile valutare la correttezza dei programmi.<br>

<b>FP1</b> Introduzione ai linguaggi funzionale: l'archetipo teorico, il \lambda-calcolo. <br>
Combinatori I, K, S. Computazione e computazioni non terminanti. Punti fissi.
</blockquote>

*Martedì 6 ottobre 2020 - Lezione 2*
<blockquote>
<b>FP2</b> Introduzione ad Haskell: lambda calcolo in Haskell<br>
Introduzione ai tipi di Haskell: polimorfismo e termini non tipabili <br>
Strategia di valutazione: call-by-name<br>
Funzioni: cittadini di prima classe.<br />

<b>OOP1</b> Introduzione agli oggetti: metafora degli oggetti come automi: stato nascosto e interfaccia<br>
Classi come descrittori degli oggetti: definizioni di classi in C++<br>
Regole di visibilità: ==private== e ==public==.<br>
Costruttori. Overloading.<br>
</blockquote>

*Martedì 13 ottobre 2020 - Lezione 3*
<blockquote>
<b>OOP2</b> Programmazione di un tipo di dati astratto in C++: i numeri razionali<br>
Invarianti di tipo di dato.<br>
Oggetti sull'Heap e oggetti sullo Stack<br>
Ridefinizione di operatori in C++<br>
</blockquote>

*Martedì 20 ottobre 2020 - Lezione 4*
<blockquote>
<b>OOP2</b> Ereditarietà e Sottotipaggio: la gerarchia dei punti<br>
Costruttori e supercostruttori. Metodi e supermetodi.<br>
Lookup dinamico dei metodi ==virtual==.<br>

<b>FP3</b> Programmazione su naturali e liste in Haskell<br>
Pattern matching.<br>
Funzionali sulle liste: ==fold==.
</blockquote>

*Martedì 27 ottobre 2020 - Lezione 5*
<blockquote>
<b>FP4</b> Ancora funzionali su liste in Haskell: ==map==, ==zipWith==.<br>
Applicazioni: prodotto scalare e prodotto tra matrici.<br>
Haskellophilìa: Clausola ==where== e list comprehension.<br>

<b>OOP3</b> Pensare le soluzioni a oggetti: architettura dell'applicazione Scacchi.<br>
Esecuzione come scambio messaggi. Delegation.<br>
Riuso del codice: spingere in codice in alto nella gerarchia delle classi.<br>
</blockquote>


---+++ <font color="#CC0000" size="+3">Diario delle Lezioni 2019-20</font>

*Giovedì 26 settembre 2019 - Lezione 1*
<blockquote>
Algoritmi e programmi: la rilevanza dello studio dei Linguaggi di Programmazione.<br />
Analisi di problemi del C che rendono difficile valutare la correttezza dei programmi.
Introduzione ai linguaggi di programmazione funzionale e a oggetti.

*Esercizio*: usare la funzione scambia senza variabile di appoggio e scrivere un programma selectSort che 
azzera tutto il vettore, mentre funziona se viene usata un'altra funzione scambia.
</blockquote>

*Giovedì 3 ottobre 2019 - Lezione 2*
<blockquote>
*FP 1*: Introduzione ai linguaggi funzionali.<br />
La funzione identità e il suo tipo. Polimorfismo e type inference.<br />
Il combinatore K e il suo tipo.<br />
Funzioni cittadini di prima classe.<br />
Il combinatore D: termini non tipabili.<br />
Alcune funzioni sulle liste: sum e length. Definizioni di funzioni per pattern matching.<br />
Funzionali sulle lise: map e fold. Liste di funzioni.<br />

*Esercizi*: <br />
1. Scrivere un programma che calcola il prodotto scalare di due liste.<br />
2. Scrivere map usando fold e senza decomporre liste via pattern matching.<br />
3. Argomentare sul perché non si può scrivere fold in termini di map.<br />
</blockquote>

*Giovedì 10 ottobre 2019 - Lezione 3*
<blockquote>
*FP 2*:
Vari esempi di prodotto scalare, zipWith.<br />
Pattern mathcing sugli interi: attenzione all'ordine con cui scrivere i casi di una definizione. Pattern matching non esaustivo.<br />
Ancora su call-by-name: perché un myAnd con la semantica di && si potrebbe scrivere in Haskell. E in C no. <br />
Definizioni e riduzioni. Confluenza e strategie di riduzione: outermost-leftmost è terminante.<br />  
Zucchero sintattico per Matematici: list comprehension. Alcuni esempi. fattori, primi, prodotto cartesiano. <br />

*Esercizi*: <br />
1. Scrivere un programma che genera numeri primi.<br />
</blockquote>

*Giovedì 17 ottobre 2019 - Lezione 4*
<blockquote>
*OOP 1*:
Introduzione alla programmazione a oggetti. Metafora degli oggetti come macchina con interfaccia e stato nascosto.<br />
Esempio: programmare i razionali: tipi astratti di dato.<br />
Il costrutto ==class==: parti pubbliche e private nella definizione di una classe.<br />
Invarianti di tipo di dato. <br />
Creazione di oggetti: metodi costruttori. Oggetti sull'heap e sullo stack.<br />
Costruttori e metodi overloaded.<br />
Architettura generale dell'applicazione sugli scacchi. La classe ==Pezzo==. <br/>

*Esercizi*: <br />
1. Completare la classe ==Razionale==.<br />
</blockquote>

*Giovedì 24 ottobre 2019 - Lezione 5*
<blockquote>
*OOP 2*:
Classi e sottoclassi: Esempio ==Pezzo== e ==Alfiere==.<br />
Relazione di sottotipaggio tra i tipi definiti da una classe e la sua sottoclasse.<br />
Metodi overriden: Esempio: ==puoiMuovere==.<br />
Il dynamic method lookup: i metodi ==virtual==.<br />
Costruttori delle sottoclassi e chiamate ai costruttori delle super classi.<br />
Tipiche tecniche di programmazione: oggetti che passano il proprio riferimento.<br />
Tipiche tecniche di programmazione: delegation. Esempio: il metodo ==print()==.<br />

*Esercizi*: <br />
1. Scrivere una gerarchia di almeno 3 sottoclassi per dimostrare gli effetti del dynamic method lookup.<br />
Far vedere che anche chiamate a metodo generate dall'esecuzione di un metodo, vengono guidate dal primo oggetto ricevente.<br />
</blockquote>

*Giovedì 31 ottobre 2019 - Lezione 6*
<blockquote>
*FP 3*:
Riscaldamento in Haskell: pattern matching sui booleani.<br />
==foldr== e (alcune del)le sue sorelle: ==foldl== e ==foldr1==.<br />
Esempi: ==reverse== quadratica (per ricorsione esplicita e usando ==foldr== `raccogliendo' i risultati delle chiamate ricorsive) <br />
e ==reverse== efficiente con uso di parametro ausiliario per memorizzare i risultati <br />
che corrisponde al `calcolo in avanti' di ==foldl==.<br />
Tipi (_polimorfismo limitato_): alcune osservazioni sulle classi di Haskell ==(Eq a)==, ==(Ord a)==, ==Num==: loro relazioni coi tipi degli OOP.<br />
Un *grande classico*: quicksort in Haskell: perla o propaganda?<br />

*Esercizi*: <br />
1. Scrivere quicksort in C sulle liste. <br />
Ovviamente potete ``tradurre'' in C l'algoritmo Haskell visto a lezione, <br />
ma che tipo di liste servono per avere un programma che sia fedele a Quicksort originale?
</blockquote>

*Giovedì 7 novembre 2019 - Lezione 7*
<blockquote>
*FP 4*:
Computazioni lazy in Haskell<br />
Definire la lista dei numeri naturali. </br>
Lista dei numeri di Fibonacci.<br />
Attenzione a scrivere definizioni produttive (cioè che producono almeno tanto input quanto ne consumano)<br />
Un esempio un po' più complesso, gli Hamming numbers. <br />
Generalizzazione degli Hamming Numbers a un insieme di generatori arbitrario.<br />
Generare ciascun Hamming Number una sola volta<br />
La principessa delle sequenze infinite: generazione dello stream dei numeri primi in Haskell.<br>

Uno scritto sulla generazione di sequenze infinite: <a href="https://arxiv.org/abs/1807.11792"><i>Computing Integer Sequences</i></a> <br />
Uno scritto sulla generazione dei numeri primi: <a href="https://arxiv.org/abs/1811.09840"><i>Three Euler's Sieve and a Fast Prime Generator</i></a>
</blockquote>

*Giovedì 14 novembre 2019 - Lezione 8*
<blockquote>
*OOP 3*:
Overloading di operatori in Haskell. Esempio ==.<br />
Overloading ed ereditarietà.<br />
Introduzione ai Template (strutture dati generiche). Esempio classe ==Stack<T>==.<br />

*Esercizio*: implementare le liste in C++. Provare a scrivere una funzione ==List<List<T>> powerset()== <br />
che genera la lista di tutte le sottoliste (interpretare una lista come un insieme e assumere gli elementi tutti diversi.<br>
Provare a scrivere la stessa funzione in Haskell (di tipo [a]->[ [a] ]).<br />

*Errata Corrige*: overloading non estende alle classe derivate in C++!!!<br />
Dalla pagina di FAQ su C++ di Soustrup: [[%ATTACHURL%/overloadingDerivedClasses.pdf][Why doesn't overloading work for derived classes?]]
</blockquote>

*Giovedì 21 novembre 2019 - Lezione 9*
<blockquote>
*OOP 4*:
Precisazione sull'overloading nelle classi derivate in C++.<br />
Standard Template Library: uso di alcune strutture dati nel progetto scacchi.<br />
Uso di iteratori. Metodi per determinare lo scacco al Re e lo scacco matto nel progetto Scacchi. <br />
</blockquote>

*Giovedì 29 novembre 2019 - Lezione 10*
<blockquote>
*OOP 5*:
Copy constructor e distruttori.<br />
Definizione di iteratori come inner class della struttura dati su cui iterano. Esempio: ==Stack== . <br />

*Esercizio*: definire l'iteratore costante per gli ==Stack==.<br />
*Esercizio* (facoltativo): definire gli alberi in C++ e alcuni iteratori su di essi (visite). <br /> 

</blockquote>

*Giovedì 5 dicembre 2019 - Lezione 11*
<blockquote>
*FP 5*:
Definizione di tipi induttivi in Haskell. Esempi: booleani, naturali, liste e alberi.<br />
Definizione di classi in Haskell.<br />

*Esercizio*: definire una funzione Haskell di codifica dagli alberi n-ari in alberi binari (e la sua inversa).
</blockquote>

*Giovedì 12 dicembre 2019 - Lezione 12*
<blockquote>
*FP 6*:
Classe ==Functor==. ==Maybe==, ==List==, e ==Tree== come istanze di ==Functor==.<br />
Funtori applicativi. <br />
La classe ==Monad== applicate al tipo ==Maybe==. Esempio: valutatore di espressioni.<br />
Osservazioni sulla gestione di caratteristiche non-funzionali in Haskell.

*Esercizio*: definire la classe ==Applicative== per le liste in modo che ==fmap2== sia ==zipWith==, ==fmap3== sia ==zipWith3== etc.
</blockquote>

*Giovedì 19 dicembre 2019 - Lezione 13*
<blockquote>
*OOP 6*:
Eredità multipla in C++. Utilità e problemi. Soluzioni alternative: interfacce in Java.<br>
Eccezioni: sollevamento, cattura, trattamento.<br>
Alcune tipiche tecniche sul trattamento di Eccezioni: masking, reflecting. <br>
</blockquote>

---+++ <font color="#CC0000" size="+3">Diario delle Lezioni 2018-19</font>

Nell'anno accademico 2018-19, le lezioni saranno divise in due.<br />
Approssimativamente 1h sarà dedicato alla Programmazione a Oggetti (in *C++*) e<br />
la mezz'ora rimanente verrà dedicato alla Programmazione Funzionale (in *Haskell*).

*Mercoledì 26 settembre 2018 - Lezione 1*
<blockquote>
Algoritmi e programmi: la rilevanza dello studio dei Linguaggi di Programmazione.<br />
Esempio: funzione C che verifica se una lista è palindroma confrontando ==L== con ==reverse(L)==: cosa può andare storto.

*OOP*: Tipi di dato in C e tipi di dato astratti (à la ADA). Tipo di dato = struttura dati + operazioni.<br />
Programmazione a Oggetti: slogan dei progettisti SmallTalk.<br />
Metafora degli oggetti come automi con interfaccia.

*FP*: Introduzione ai linguaggi funzionali.<br />
Computazione come riduzione di espressioni. Assenza della memoria.<br />
Definizioni e riduzioni. Confluenza e strategie di riduzione.<br />
Cenni ai tipi e all'inferenza di tipo.<br />
Breve storia della programmazione funzionale (I): il Lambda-cacolo.
</blockquote>

*Mercoledì 3 ottobre 2018 - Lezione 2*
<blockquote>

*OOP*: Architettura generale dell'applicazione filo conduttore, gli Scacchi in C++<br />
Introduzione al concetto di classe.<br />
Classi e sottoclassi. Esempi: ==Scacchiera==, ==Pezzo==, e i pezzi veri e propri.<br />
Definizioni di classe e metodi. Visibilità: ==public== e ==private==.<br />
Metodi con lo stesso nome: *overloading*. Esempi: ==puoiMuovere(Casella, Casella, Scacchiera)== <br />
e ==puoiMuovere(Casella, Scacchiera)==.

*FP*: Prime funzioni in Haskell e loro tipi: identità, proiezione primo elemento.<br />
Tipi polimorfi. Funzioni non terminanti e strategia di riduzione.<br />
Il tipo di dato principe in Haskell: le liste. Notazioni. Funzione ==length== e pattern matching.

[[%ATTACHURL%/lez-2018-10-3.hs][Codici Haskell Lezione 2]]
</blockquote>

*Mercoledì 10 ottobre 2018 - Lezione 3*
<blockquote>

*OOP*: Sottoclassi ed *ereditarietà*: la classe ==Cavallo==. <br />
Specializzazione dei metodi: *overriding*.<br />
Il problema dell'invocazione dei metodi in presenza di overriding: *dynamic method lookup* e ==virtual==.<br />
Pro e cons di static vs dynamic binding: flessibilità vs efficienza.

*FP*: Ancora funzioni su liste: ==head== e ==tail==: pattern non esaustivi ed eccezioni.<br />
Funzioni ==appendi== e ==rovescia==. Clausola ==where==.<br />
Funzione palindroma. Type classes: *polimorfismo limitato*.<br />
Esempio: tipo ==(Eq a)== dei tipi che ammettono uguaglianza.<br />
Definizione ricorsiva di liste infinite. Primi cenni alla *laziness*.

[[%ATTACHURL%/lez-2018-10-10.hs][Codici Haskell Lezione 3]]
</blockquote>

*Mercoledì 17 ottobre 2018 - Lezione 4*
<blockquote>
*OOP*
Ripasso sul virtual. I due metodi ==puoiMuovere()==. Lookup del metodo riparte sempre dal primo oggetto ricevente.<br />
Il puntatore all'oggetto stesso ==this==.<br />
Approfondimenti sulla relazione di sottotipaggio e assegnazioni ben tipate. Prudenza del type-checker.<br />
Creazione di oggetti: costruttori: necessità e invocazione (con la ==new== e quando allocati sullo Stack).<br />
Costruttore di Default. Costruttori ==protected==: classi da cui non si vogliono creare oggetti.<br />
Invocazione del costruttore della super-classe, problemi col costruttore di default.

*FP*: Alcune piccole utilità: equazioni guardate, pattern, funzioni anonime (lambda espressioni).<br />
Funzioni di ordine superiore ==map== e ==reduce== (o ==foldr==).<br />
Definizione di ==map== usando ==reduce==.
Applicazione al calcolo del prodotto scalare.

[[%ATTACHURL%/lez-2018-10-17.hs][Codici Haskell Lezione 4]]
</blockquote>

*Mercoledì 24 ottobre 2018 - Lezione 5*
<blockquote>
*OOP*
Alcune classi dell'applicazione Scacchi: ==Scacchiera== e ==Casella==.<br />
Tipica tecnica di programmazione: *delegation*. Esempio: metodo ==void print()==.<br />
Metodi virtual puri. Esempio: il metodo ==print()== nella classe ==Pezzo==.
Campi pubblici/privati e un diffuso malcostume: metodi setters e getters.<br />
Un po' di zucchero sintattico: ridefinizione degli operatori predefiniti dal linguaggio.<br />

*FP*: Zucchero sintattico per matematici: List comprehension.<br />
Ridefinizione di funzioni su liste usando ==map==, ==foldr== e ==foldl==.<br />
==foldr== come generalizzazioni delle ricorsioni che calcolano il risultato al "ritorno" delle chiamate ricorsive.<br />
==foldl== come generalizzazioni delle ricorsioni che calcolano il risultato all'"andata" delle chiamate ricorsive.<br />
Esempio di famoso algoritmo in Haskell: ==quicksort==. Limiti della versione Haskell.

[[%ATTACHURL%/lez-2018-10-24.hs][Codici Haskell Lezione 5]]
</blockquote>

*Mercoledì 31 ottobre 2018 - Lezione 6*
<blockquote>
Discussione riassuntiva dei concetti introdotti nelle Lezioni 1-5.<br>
Virtù composizionali della programmazione a oggetti e riuso del codice.<br>
L'impatto di: metodi virtuali, regole di visibilità, sottotipaggio, ereditarietà.<br>
Impatto sul riuso del codice.<br>
Virtù composizionali della programmazione funzionale.<br>
L'impatto di: tipi polimorfi, funzioni di ordine superiore, funzioni de-curryficate, astrazione.<br>
Un esempio: moltiplicazione di matrici in Haskell. (vedi codici lezione precedente). <br>
</blockquote>


*Mercoledì 7 novembre 2018 - Lezione 7*
<blockquote>
Nella settimana degli esoneri, discussione ed esercizi in Haskell e in C++.
</blockquote>

*Mercoledì 14 novembre 2018 - Lezione 8*
<blockquote>
*OOP*
Puntatori e references: confronto ed esempi.<br />
Passaggio per valore di oggetti: copy constructor.<br />
Distruzione di oggetti: distruttori e ==delete==. Lifetime degli oggetti.<br />

*FP*: 
Introduzione alla valutazione lazy.<br />
Alcuni esempi notevoli: streams dei naturali, potenze, numeri di fibonacci<br />
</blockquote>

*Mercoledì 21 novembre 2018 - Lezione 9*
<blockquote>
*OOP*
Polimorfismo generico in C++: Templates.<br>
Esempio di definizione di un template: gli Stack in C++.<br>
Introduzione all'uso di eccezioni: sollevamento, cattura, trattamento.<br>

*FP*: 
Alcuni interessanti problemi di generazione di streams: Hamming numbers.<br>

Uno scritto sulla generazione di sequenze infinite: <a href="https://arxiv.org/abs/1807.11792"><i>Computing Integer Sequences</i></a>
</blockquote>

*Mercoledì 28 novembre 2018 - Lezione 10*
<blockquote>
*OOP*
Introduzione all'uso di iteratori su strutture dati.<br>
Stack con iteratori.<br>
Introduzione alle STL (= Standard Template Library). 
Applicazioni al progetto scacchi: metodo ==allMoves==.<br>

*FP*: 
La principessa delle sequenze infinite: generazione dello stream dei numeri primi in Haskell.<br>
Uno scritto sulla generazione dei numeri primi: <a href="https://arxiv.org/abs/1811.09840"><i>Three Euler's Sieve and a Fast Prime Generator</i></a>
</blockquote>

*Mercoledì 5 dicembre 2018 - Lezione 11*
<blockquote>
*OOP*
Applicazione di concetti visti: metodi ==move== e ==scaccoMatto==.<br>

*FP*: 
-.</blockquote>

*Mercoledì 12 dicembre 2018 - Lezione 12*
<blockquote>
*OOP*:
Revisione delle principali classi della Standard Template Library: ==vecotr==, ==deque==, ==arrayList==.<br>
Il caso della classe ==stack==.<br>
Cenni agli Algorithms. Il problema della modifica di una struttura dati durante una scansione di un iteratore: ==const_iterator==. 

*FP*: 
Definizione di tipi in Haskell. ==type==, ==data==, ==Maybe==.<br>
Alcuni esempi di tipi induttivi: naturali, liste, alberi.
</blockquote>

*Mercoledì 19 dicembre 2018*  Lezione annullata (Festa di Matematica).

*Mercoledì 9 gennaio 2019 - Lezione 13*
<blockquote>
Classi in Haskell. Classi pre-definite (==Eq==, ==Ord==, ==Num==, etc.).<br>
Definizioni di classi e istanze.<br>
Confronti con C++ (ereditarietà multipla) e Java (interfacce).
</blockquote>

*Mercoledì 16 gennaio 2019 - Lezione 14*
<blockquote>
*OOP*
?.<br>

*FP*: 
Derivazioni di programmi da specifici. Esempio: minimo intero libero in una lista.</blockquote>

---+++ <font color="#CC0000" size="+3">Diario delle Lezioni 2017-18</font>

Nell'anno accademico 2017-18, il contenuto delle lezioni è stato del tutto analogo alle lezioni<br />
tenute nell'anno accademico 2016-17. Sono state tenute 11 lezioni a cominciare da giovedì 5 ottobre (in aula G) <br />
e poi tutti i mercoledì (in aula F, escluso il primo novembre).

Nel mese di gennaio sono state svolte 2 lezioni di introduzione alla programmazione funzionale in Haskell (10 e 17 gennaio), <br />
che non saranno parte del programma di Esame.

*Mercoledì 10 gennaio 2018 - Lezione 12*
<blockquote>
Breve introduzione al Lambda-calcolo: sintassi, beta-regola.<br />
Alcuni esempi: identità, proiettori, termini non terminanti, numerali di Church, operatore di punto fisso.<br />
A taste of Haskell: sintassi, tipi polimorfi, riduzione.<br />
Confluenza e strategia di valutazione _call by name_.<br />
Introduzione alle liste e alla ricorsione su liste.<br />
Laziness: generazione (lazy) di *tutti* i numeri di fibonacci in una riga.<br />
</blockquote>

*Mercoledì 17 gennaio 2018 - Lezione 13*
<blockquote>
Ordine superiore: permutatore di argomenti di una funzione (binaria).<br />
Ancora esempi di programmazione su liste: prodotto scalare tra vettori (come liste).<br />
Esempio notevole di ordine superiore: moltiplicazione tra matrici (come liste di liste).<br />
Esempio notevole della concisione dei programmi Haskell: ==qSort==. <br />
Ancora sui tipi polimorfi: tipo principale e termini tipabili in Haskell: ==x x where x = \y -&gt; y==.

</blockquote>

---+++ <font color="#CC0000" size="+3">Diario delle Lezioni 2016-17</font>

I numeri in grassetto puntano ai capitoli del libro _Thinking in C++_ che trattano l'argomento considerato.

<div align="justify" style="margin-left: 5%; margin-right: 10%;">
<b>Giovedì 6 ottobre 2016 - Lezione 1</b> <blockquote>
Breve presentazione del corso. <br />
Introduzione agli oggetti. <br />
Presentazione dell'applicazione che verrà sviluppata durante le lezioni: verifica di una partita a scacchi.<br />
Scomposizione di un problema con la metodologia a oggetti: individuazioni dei tipi di dato fondamentali.<br />
Interfaccia di un oggetto.<br />
</blockquote>

*Giovedì 13 ottobre 2016 - Lezione 2*
<blockquote>
Definizioni di classi.<br />
Campi e metodi *[4]*.<br />
Regole di visibilità: public e private *[5]*.<br />
Classe ==Colore==.<br />
Costruttori *[6]*.<br />
Oggetti sull'heap e sullo stack *[13]*.<br />
Ridefinizione di operatori definiti dal linguaggio.<br />
Overloading. <br />
</blockquote>

*Giovedì 20 ottobre 2016 - Lezione 3*
<blockquote>
Ereditarietà e sottotipaggio.<br />
Le classi ==Re==, ==Pedone==, etc.<br />
Metodi ==virtual== : dynamic lookup.<br />
</blockquote>

*Giovedì 27 ottobre 2016 - Lezione 4*
<blockquote>
Esempio di metodo virtual: ==puoiMuovere==.<br />
Invocazione dei metodi della superclasse.<br />
Invocazione dei costruttori della superclasse.<br />
Visibilità ==protected==.<br />
Esercizio sul dynamic lookup.<br />
</blockquote>

*Giovedì 3 novembre 2016 - Lezione 5*
<blockquote>
Ancora su ereditarietà e sottotipaggio: type safety. Prudenza del type-checker.<br />
Classi astratte. Metodi puramente virtual.<br />
Introduzione ai Template. Riuso del codice.<br />
Esempio: la classe ==Stack==.<br />
</blockquote>

*Giovedì 10 novembre 2016 - Lezione 6*
<blockquote>
Referenze e puntatori: vantaggi e svantaggi.<br />
Copy Constructor.<br />
Esempio di template: array con check sui bounds. Ridefinizione di operatori.<br />
</blockquote>

*Giovedì 17 novembre 2016 - Sospensione per Esoneri*

*Giovedì 24 novembre 2016 - Lezione 7*
<blockquote>
Iteratori.<br />
</blockquote>

*Giovedì 1 dicembre 2016 - Lezione 8*
<blockquote>
Analisi dell'architettura generale del progetto Scacchi.<br />
Analisi di alcuni metodi della classe partita: uso di iteratori e STL per scacco e scacco matto.<br />
</blockquote>

*Giovedì 8 dicembre 2016 - Festa dell'Immacolata Concezione*

*Giovedì 15 dicembre 2016 - Lezione 9*
<blockquote>
Implementazioni di iteratori in C++.<br />
Nested class.<br />
Esempio: Stack con iteratori.<br />
</blockquote>

*Giovedì 12 gennaio 2017 - Lezione 10*
<blockquote>
Chiarimenti su progetto ed esame.<br />
Eccezioni in C++. Motivazioni, sintasssi e uso delle eccezioni.<br />
</blockquote>

</div>

---+++ <font color="#0088BB" size="+2"> Diario delle Lezioni 2015-16</font>

Per l'anno accademico 2015-16 non è stato compilato un dettagliato Diario delle Lezioni, <br />
in larga parte analogo a quello sottostante relativo all'anno accademico 2014-15,<br />
anche se gli argomenti sono stati presentati in un ordine leggermente diverso.

Nell'anno accademico 2015-16, tuttavia, sono stati inoltre affrontati, con più dettaglio, i seguenti
argomenti:
   * Copy Constructor e problematiche relative al passaggio di oggetti come parametro per valore *[11]*;
   * Carrellata sulle principali librerie di strutture dati (Standard Template Library, STL) e iteratori *[4], vol. 2*.

---+++ <font color="#228B22" size="+2"> Diario delle Lezioni 2014-15</font>

<div align="justify" style="margin-left: 5%; margin-right: 10%;">
<b>Giovedì 2 ottobre 2014 - Lezione 1</b> <blockquote>
Presentazione del corso. <br />
Breve discussioni sulle famiglie di linguaggi di Programmazione. <br />
Obiettivi di un linguaggio di programmazione: fornire un insieme di astrazioni <br />
(e meccanismi per creare astrazioni) al programmatore.<br />
Linguaggi funzionali e Procedurali.<br />
La centralità dei dati: tipo di dato = struttura dati + operazioni *[1]*.<br />
<br />
</blockquote>

*Giovedì 9 ottobre 2014 - Lezione 2*
<blockquote>
Definizione di classi.<br />
Campi e metodi *[4]*.<br />
Regole di visibilità: public e private *[5]*.<br />
Interfaccia di un oggetto.<br />
Overloading di metodi. <br />
</blockquote>

*Giovedì 16 ottobre 2014 - Lezione 3*
<blockquote>
Costruttori *[6]*.<br />
Oggetti sull'heap e sullo stack *[13]*.<br />
Ereditarietà *[14]*.<br />
<br />
</blockquote>

*Giovedì 23 ottobre 2014 - Lezione 4*
<blockquote>
Metodi virtual: polimorfismo (o Dynamic Method Lookup) *[15]*.<br />
Ancora sui costruttori: chiamate ai costruttori della superclasse *[14]*.<br />
Distruttori  <b>[6]</b>.<br />
Esempio: struttura dati Stack in C++ *[6]*.<br />
</blockquote>

*Giovedì 30 ottobre 2014 - Lezione 5*
<blockquote>
Passaggi di parametri: reference *[11]*.<br />
Passaggio di oggetti per valore: copy constructor *[4]*.<br />
Conseguenze sul polimorfismo.<br />
Metodi statici *[10]* e costanti *[8]*.<br />
<br />
</blockquote>

*Giovedì 6 novembre 2014 - Lezione **
<blockquote>
Lezione sospesa causa allerta meteo.
<br />
</blockquote>

*Giovedì 13 novembre 2014*
<blockquote>
Sospensione per prove intermedie.
<br />
</blockquote>

*Giovedì 20 novembre 2014 - Lezione 6*
<blockquote>
Esempio di progettazione di applicazione a oggetti: Scacchi.<br />
Decomposizione del problema seguendo una metodologia a oggetti.<br />
Utilità di avere supertipi comuni: la classe Pezzo.<br />
Delegazione di compiti ad altri oggetti.<br />
Comunicazione tra oggetti. Passaggi di riferimenti tra oggetti.<br />
<br />
</blockquote>

*Giovedì 27 novembre 2014 - Lezione 7*
<blockquote>
Presentazione secondo homework.<br />
Introduzione all'uso di eccezioni *[7], vol. 2*.<br />
<br />
</blockquote>

*Giovedì 4 dicembre 2014 - Lezione 8*
<blockquote>
Introduzione ai Template *[16]*.<br />
Cenni all'eredità multipla.
<br />
</blockquote>

*Giovedì 11 dicembre 2014 - Lezione 9*
<blockquote>
Esercitazione: progettazione e implementazione degli insiemi.<br />
Utilizzo di una template Set<T>.<br />
<br />
</blockquote>

*Giovedì 18 dicembre 2014 - Lezione **
<blockquote>
Lezione annullata causa Festa di Matematica.
<br />
</blockquote>

*Giovedì 15 gennaio 2015 - Lezione 12*
<blockquote>
Lezione Annullata.
<br />
</blockquote>

-- Users.IvanoSalvo - 3 Oct 2018
</div>
This topic: LDPMat > WebHome > DiarioDelleLezioni
Topic revision: r64 - 2020-10-25 - IvanoSalvo