Merge branch 'main' of https://github.com/CaffeLatteIV/wiki

+

+# Tre bel panino wiki

+

+Raccolta di appunti, info e documentazione per il mio server e i miei servizi.

+

+## TODO

+

+- Montare telecamere (Frigate o Shinobi): Un sistema NVR (Network Video Recorder) locale per gestire, registrare e visualizzare i flussi video delle tue telecamere IP.

+- Riconoscimento facciale AI (CompreFace o Double Take): Un'integrazione di intelligenza artificiale che analizza i flussi video (spesso abbinata a Frigate) per identificare volti noti, auto o animali, attivando automazioni specifiche.

+- Diagramma networking casa

+- Diagramma servizi server

+- Monitoraggio uptime e risorse (Uptime Kuma + Grafana/Prometheus): Una suite di controllo: Uptime Kuma per avere una dashboard stile "semaforo" sui servizi attivi, e Grafana per grafici dettagliati sull'uso di CPU, RAM e disco del server.

+- overseerr -> seerr

+- Refactor server Plex: maybe, dischi in raid 0

+- Reverse proxy di tutto (Nginx Proxy Manager, Traefik o Caddy)

+- IDS/IPS + Firewall + Wireshark (OPNsense + Suricata/CrowdSec): Un sistema di difesa avanzato dove il firewall blocca le porte, Suricata/CrowdSec fanno da sensori per rilevare e bannare automaticamente gli hacker (IDS/IPS).

+- Controllo cancello automatico (ESPHome/Shelly via Home Assistant): La "domotizzazione" del cancello tramite un relè locale (es. Shelly), che ti permette di aprirlo da smartphone, tramite geofencing o dal cruscotto dell'auto (Android Auto/CarPlay).

+- DNS (AdGuard Home vs Pi-hole vs BIND): Il sistema di risoluzione dei nomi a dominio. Qual è il migliore? BIND è complesso ed enterprise; AdGuard Home oggi è spesso preferito a Pi-hole perché supporta DoH/DoT (DNS over HTTPS/TLS) nativamente e ha un'interfaccia più moderna. (uno per servere per failover)

+- Hosting immagini (Immich o Nextcloue Memories): Un'alternativa self-hosted identica a Google Foto. Consiglio: Usa immich (piu veloce)

+- Home Assistant (HAOS): compatibile con molti sistemi (Zigbee, Wi-Fi, Apple, Google, sensori vari).

+- Trello (Planka, Kanboard o Focalboard): Piattaforme Kanban per la produttività. Consiglio planka

+- Firewall (pfSense o OPNsense): Un router/firewall software di livello enterprise (da installare su un mini-PC dedicato) da mettere "a monte" di tutto per gestire le tue reti (VLAN), le VPN (WireGuard) e blindare l'accesso a internet.

+- Wallabag: Il tuo raccoglitore personale "leggi più tardi" (tipo Pocket), che estrae il testo e le immagini dagli articoli web, ripulendoli da pubblicità e distrazioni per farteli leggere comodamente anche offline.

+- Minecraft server (Pterodactyl o Pelican)

+

+## Servizi da hostare

+

+- Gluetun: Un client VPN containerizzato che funge da "colla" sicura per instradare e proteggere il traffico di rete degli altri tuoi container Docker.

+- Mealie: Un gestore di ricette e pianificatore di pasti con un'interfaccia moderna e la comodissima funzione di importazione automatica dagli URL.

+- Grocy: Un vero e proprio sistema gestionale (ERP) per la casa, ideale per tracciare l'inventario della dispensa, le date di scadenza e le faccende domestiche.

+- Firefly III: Un solido manager per le finanze personali che ti permette di tracciare conti, spese e budget mantenendo i tuoi dati finanziari privati.

+- Paperless-ngx: Un archivio digitale intelligente che utilizza l'OCR per scansionare, leggere, indicizzare e organizzare in automatico tutti i tuoi documenti e PDF.

+- Planka: Un'elegante e reattiva alternativa open source a Trello per gestire task e progetti tramite bacheche Kanban.

+- Dozzle: Un visualizzatore web leggerissimo per leggere, cercare e monitorare in tempo reale i log dei tuoi container Docker senza toccare la riga di comando.

+- Kurrier: Un workspace moderno e unificato di nuova generazione per gestire comodamente email, calendari, contatti e storage dal browser.

+- Termix: Una piattaforma web per la gestione dei server (ottima alternativa self-hosted a Termius) che offre terminale SSH, tunneling, file manager remoto e gestione Docker.

+- Authentik (Autentik): Un potente provider di identità (IdP) che funge da Single Sign-On (SSO) per centralizzare l'autenticazione e blindare l'accesso ai tuoi servizi esposti.

+**Uni**

+

+- [Prova](./sistemi.md)

+# Gestione memoria (slide 36)

+

+scrivi le def di regola di scope dinamico e statico in s02

+

+### Il display

+

+Alternativa alla catena statica per implementare scope statico (e' piu veloce ma richiede mem in piu (per l'array))

+

+Si puo ridurre il costo h ad una costante usando la tecnica del display

+

+- la catena statica viene rappresentata mediante un array

+ - i-esimo elem dell array = punt all'RdA del sottoprogramma di livello di annidamento i attivo per ultimo

+- quindi: - `Display[1]=RdA` di una proc P di top level - `Display[2]=RdA` di una proc Q dichiarata in P - ... - `Display[2]=RdA` della proc attiva in questo momento (dichiarata dentro quella che si trova in `Display[i-1]`)

+

+Se il sottoprogramma corrente è annidato a livello i, un oggetto che è in uno scope esterno di h livelli può essere trovato guardando il punt a RdA nel display alla posizione j = i - h

+

+Esempio:

+

+

+Se proc corrente annidata a livello i, lo scope esterno di h livelli si ottiene in `Display[i - h]`

+Con Display in memoria un oggetto è trovato con due accessi, uno per il display e uno per l’oggetto

+

+

+

+

+Display o catena statica ?

+• Rari annidamenti di profondità > 3, quindi lunghezza max di catena statica = 3

+• Tecniche di ottimizzazione possono migliorare gli accessi alle catene usate più frequentemente (tenendo nei registri i puntatori)

+• Il display è più costoso da mantenere della catena statica nella sequenza di chiamata ...

+• Conclusione: display poco usato nelle implementazioni moderne…

+

+### Scope dinamico

+

+Con scope dinamico l’associazione nomi-oggetti denotabili dipende

+– dal flusso del controllo a run-time

+– dall’ordine con cui i sottoprogrammi sono chiamati - La regola generale è semplice: l’associazione corrente per un nome è quella determinata per ultima nell’esecuzione (non ancora distrutta).

+

+Implementazione ovvia:

+

+- Memorizzare i nomi negli RdA

+- Ricerca per nome risalendo la pila

+- Esempio: chiamate A,B,C,D

+

+

+

+Variante: A-list

+Le associazioni sono memorizzate in una struttura apposita (manipolata come una pila)

+Es: chiamate A B C D

+

+(in grigio le associazioni non attive)

+In pratica se ho x a livello A e x al livello B, quando parto da B o da sotto B risalendo trovo x(x deve essere attiva = visibile dal blocco corrente)

+quando mi sposto (es da A a C) devo rendere non visibili le var di altri blocchi (es. B non e' visibile da C o D)

+

+Per ogni record che alloco sulla pila devo esplicitare le var visibili

+nei libri la regola di visibilita' viene prima della regola di scope (nella realta' dipende)

+

+le associazioni non visibili lo sono per due casi:

+

+1. sono state riscritte

+2. sono invisibili secondo la regola di visibilita'

+

+Costi delle A-list

+

+- Molto semplice da implementare

+- Occupazione mem (nomi presente esplicitamente)

+- costo di gestione (ingresso uscita da blocco e inserzione rimozione blocchi dalla pila)

+- tempo di accesso (lineare nella profondita della a list)

+

+Possiamo ridurre il tempo d’accesso medio, aumentando il tempo di ingresso/uscita da blocco..

+

+#### Tabella centrale dei riferimenti, CRT

+

+evita le lunghe scansioni delle A list

+una tabella mantiene tutti i nomi distinti del programma

+

+- se i nomi sono noti statitcamente si puo accedere all elemento della tabella in tempo costante

+- altrimenti accesso hash

+

+Ad ogni nome e' associata la lista delle associazioni di quel nome

+

+- la piu recente e' la prima

+- le altre (disattivate) seguono

+

+Tempo di accesso costante

+

+

+

+

+

+nell'ultima tabella v e'dichiarato non visibile (0)

+

+#### Costi della CRT

+

+Gestione più complessa di A-list

+Meno occupazione di memoria:

+– se nomi noti staticamente, i nomi non sono necessari

+– in ogni caso, ogni nome memorizzato una sola volta

+

+Costo di gestione

+– ingresso/uscita da blocco (manipolazione di tutte le liste dei nomi presenti nel blocco)

+Tempo di accesso

+– costante (due accessi indiretti)

+Possiamo ridurre il tempo d’accesso medio, aumentando il tempo di ingresso/uscita da blocco...

+

+Es. esrcizio

+

+Si assuma che un generico linguaggio imperativo a blocchi. Il blocco A contenga una chiamata alla funzione f. Il numero dei record di attivazione (RdA) presenti run time sulla pila fra il RdA di A e quello della chiamata di f e' fissato staticamente o puo valere dinamicamente? Motivare la risoposta

+# Strutturare il controllo

+

+Controllo del flusso

+

+**Espressioni**:

+

+- notazioni

+- valutazione

+- problemi

+

+**Comandi**

+

+- assegnamento

+- sequenziale

+- condizionale

+

+**Comandi iterativi**

+**Ricorsione**

+

+## Espressioni

+

+Un’espressione un’entità sintattica la cui valutazione produce un valore oppure non termina, nel qual caso l’espressione è indefinita.

+– infissa a + b

+– prefissa (polacca) + a b

+– postfissa (polacca inversa) a b +

+

+### Semantica delle espressioni: notazione infissa

+

+Precedenza fra gli operatori:

+

+a + b \* c ** d ** e / f ??

+if A < B and C < D then ??

+(in Pascal Errore se A,B,C,D non sono tutti booleani)

+

+Di solito operatori aritmetici precedenza su quelli di confronto che hanno precedenza su quelli logici (nono pascal)

+APL, Smalltalk: tutti gli op hanno eguale precedenza (si devono usare le parentesi)

+

+Associativita'

+

+15 - 4 - 3 ?? (15 -4) -3

+5 ** 2 ** 3 ?? 5 ** (2 ** 3)

+

+Non sempre ovvio (apl: 15-4-3 diventa 15-(4-3))

+

+### Semantica delle espressioni: notazione postfissa

+

+Molto piu semplice della infissa

+

+- non servono le regole di precedenza

+- non servono regole di associativita'

+- non servono parentesi

+- valutazione semplice usando una pila

+

+Valutazione usando una pila

+

+1. Leggi il prossimo simbolo dell’exp. e mettilo sulla pila

+2. Se il simbolo letto è un operatore:

+ – applica a operandi immediatamente precedenti sulla pila,

+ – memorizza il risultato in R,

+ – elimina operatore ed operandi dalla pila

+ – memorizza il valore di R sulla pila.

+3. Se la sequenza da leggere non è vuota torna a (1).

+4. Se il simbolo letto un operando torna a (1).

+

+### Semantica delle espressioni: notazione prefissa

+

+Molto piu semplice della infissa:

+

+- no regole di precedenza

+- no regole di associativita

+- no parentesi

+- valutazione smplce usando una pila (piu complicata di quella postfissa, dobbiamo contare gli operandi che vengono letti)

+

+## Valutazione delle espressioni

+

+• Le espressioni internamente sono rappresentate da

+alberi

+• Visite diverse dell’albero producono le varie notazione

+lineari:

+– Simmetrica -> infissa

+– Anticipata -> prefissa

+– Differita -> postfissa

+

+A partire dall'albero il compilatore prodice il codice oggetto oppure l'interprete valuta l'espressione

+In entrambi i casi l'ordine di valutazione delle sottoespressioni e' importante per vari motivi:

+– Effetti collaterali (modifiche di var che non sono )

+– Aritmetica finita (overflow)

+– Operandi non definiti ()

+– Ottimizzazione

+

+Es:

+`a+f(b)) * (c+f(b))`

+

+se f(n) = {x++ return x}

+chiamate diverse della stessa funzione possono provocare una modifica di valori e channo effetti diversi.

+Altro es:

+`a+f(b)) * (c+f(b))`

+Se f modifica b il risultato da sinistra a destra e diverso di quello da destra a sinistra

+• In alcuni linguaggi non sono ammesso funzioni con effetti laterali nelle espressioni

+• In Java è specificato chiaramente l’ordine (da sinistra a destra)

+

+### Operandi non definiti

+

+in C:

+

+```c

+a == 0 ? b : b/a

+```

+

+presuppone una valutazione **lazy**: si valutano solo gli op strettamente necessari.

+E'importante sapere se il ling adotta una valutazione lazy oppure **eager** (tutti gli operandi sono comunque valutati)

+

+### Valutazione corto-circutio

+

+Nel caso delle espressioni booleane spesso la vlutazione lazy è detta corto-circuito:

+

+```c

+a == 0 || b/a > 2

+```

+

+– Con valutazione lazy (corto circuito, come in C) => VERO

+– Con valutazione eager => possibile errore

+

+Visto che eager controlla tutti i parametri puo stare facendo una divisione con zero se a=0

+

+```

+p := lista;

+while (p <> nil ) and (pˆ.valore <> 3) do

+p := pˆ.prossimo;

+```

+

+(in pascal da errore)

+

+## Comandi

+

+Un comando e'un entita' la cui valutazione non necessariamente restituisce un valore, ma puo avere un affetto collaterale

+

+- effetto collaterale: modifica stato della computazione senza restituire un valore

+

+I comandi:

+

+- sono tipici del paradigma imperativo

+- non sono presenti nei paradigmi funzionali e logici

+- in alcuni casi restituiscono un valore

+

+## Variabili

+

+Nei ling imperativi (pascal, c, Ada...) la variabile e' modificabile (contenitore di val, normalmente di un certo tipo ed ha un nome)

+

+Il val nel contenitore puo essre modificato mediante il comando di assegnamento

+

+### Assegnamento

+

+`x:=2`

+`X = X +1` si noti il diverso ruolo delle X

+

+- la X di sinistra e'un **l-value**, ossia un valore che denota una locazione (e puo comparire a sinistra di un assegnamento)

+- la X di destra e'un **r-value** ossia un valore puo'essere contenuto in una locazione (e puo comparire a destra di un assegnamento)

+

+In generale

+exp1 Opass exp2

+

+Normalmente la valutazione di un assegnamento non restituisce un valore ma produce un ``side effect’’ (effetto collaterale)

+– In alcuni linguaggi l’assegnamento resituisce anche un valore. In C:

+x= 2 restituisce 2 quindi possiamo scrivere Y = X = 2

+

+### Modelli di variabile diversi

+

+Linguaggi funzionali (Lisp, ML, Haskell, Smalltalk): modello analogo a quella della matematica. Una variabile denota un valore e non è modificabile

+• Linguaggi logici: modello analogo a quello dei funzionali, ma con la possibilità di modificare (entro certi limiti) il valore associato alla variabile

+• Clu: modello a oggetti, chiamato anche modello a riferimento

+• Java:

+– variabile modificabile per i tipi primitivi (interi, booleani ecc.)

+– modello a riferimento per i tipi classe

+

+### Modello a riferimento

+

+na variabile è un riferimento ad un valore, che ha un nome X ----> 2

+Analogo alla nozione di puntatore, ma senza le possibilità di manipolazione delle locazioni dei puntatori: le locazioni qui possono essere manipolate solo implicitamente

+

+

+A destra, se gli oggetti riferiti da X e Y sono modificabili (es.oggetti Java) modifiche fatte attraverso la X si riflettono sull’oggetto riferito da Y

+

+### Operatori di assegnamento

+

+X := X+1

+

+- doppio accesso alla locazione di a (a meno di ottimizzazione del compilatore)

+- poco chiaro; in alcuni casi puo’ causare errori

+ 

+

+### Espressioni e comandi (l. imperativi)

+

+lgol 68: expression oriented

+– non c’e’ nozione separata di comando

+– ogni procedura restituise un valore

+

+Pascal: comandi separati da espressioni

+– un comando non puo’ comparire dove e’ richiesta un’espressione

+– e viceversa

+

+C: comandi separati da espressioni

+– espressioni possono comparire dove ci si aspetta un comando

+– assegnamento (=) permesso nelle espressioni

+

+### Ambiente e memoria

+

+Due variabili diverse possono denotare lo stesso oggetto (aliasing)

+– come si rappresenta questa situazione in termini di stato ?

+– la semplice funzione Stato: Nomi ---> Valori non basta

+

+La semantica dei linguaggi imperativi usa:

+– Ambiente: Nomi ----> Valori Denotabili

+– Memoria: Locazioni ---> Valori Memorizzabili

+

+Nei linguaggi imperativi sono presenti tre importanti domini semantici:

+– Valori Denotabili (quelli a cui si può dare un nome)

+– Valori Memorizzabili (si possono memorizzare)

+– Valori Esprimibili (risultato della valutazione di una exp.)

+

+> Nota: I linguaggi funzionali usano sono l’ambiente

+

+### Comandi per il controllo sequenza

+

+Comandi per il controllo sequenza esplicito

+– ;

+– blocchi

+– goto

+Comandi condizionali

+– if

+– case

+Comandi iterativi

+– iterazione determinata (for)

+– iterazione indeterminata (while)

+

+### Comando sequenziale e blocchi

+

+C1 ; C2 (significa che viene prima eseguito c1 e poi c2)

+– E’ il costrutto di base dei linguaggi imperativi

+– Ha senso solo se ci sono side-effects

+– in alcuni linguaggi il ``;’’ più che un comando sequenziale è un

+terminatore

+

+Algol 68, C: Il valore di un comando composto e’ quello dell’ultimo comando.

+

+Comando composto

+– può essere usato al posto di un comando semplice

+– Algol 68, C (no distinzione espressione-comando): il valore di un comando composto e’ quello dell’ultimo comando

+

+````{ begin

+… …

+} end```

+````

+

+### GOTO

+

+Acceso dibattito negli anni 60 sull'utilita del goto

+Alla fine considerato dannoso

+

+## Programmazione strutturata

+

+- GOTO sconfitto perche'considerato contrario alla programmazione strutturata

+- Nata negli anni 70 antesignana della programmazione OOP

+

+Caratteristiche:

+

+- design top down

+- codice modulare

+- nomi identificatori significativi

+- uso esteso commenti

+- tipi di dato strutturato

+- comandi per il controllo strutturato

+- ...

+

+### Comandi di controllo strutturati

+

+Un solo punto di ingressoe un solo punto d'uscita

+

+- la scansione lineare del testo corrisponde al flusso di esecuzione

+- fondamentale per la comprensione del codice

+

+Comandi strutturati

+

+- for if while case

+- non e'il caso del goto

+

+Permette codice strutturato e non spaghetti code

+

+### Comando condizionale

+

+`if B then C_1 esle C_2`

+

+Introdotto con algol 60

+Varie regole per evitare ambiguita' in presenza di if annidati (es. `if B then C1 else C2 endif`)

+

+Case:

+Discendente del goto di fortran e del switch di algol 60

+

+- Molte versioni nei vari linguaggi

+

+Il case, in confronto all'if-then-else e' piu leggibile e piu efficiente se compilato bene

+

+## Iterazione

+

+iterazione e ricorsione sono due meccanismi fondamentali che permettono di ottenere formalismi di calcolo Turing completi. Senza di essi avremmo automi a stati finiti.

+

+Iterazione:

+

+- indeterminata: cicli controllati logicamente (while, repeat)

+- determinata: cicli controllati numericamente (for, do) con numero di ripetizioni del ciclo determinate all'inizio di esso

+

+### Iterazione indeterminata

+

+```

+while condizione do comando

+```

+

+Introdotto in Algol-W rimasto in pascal e moli altri linguaggi

+

+In pascal esiste anche la versione post-test:

+

+```

+repeat comando until codizione

+```

+

+Equivalente a `while not condizione do comando`

+

+L'iterazione e'indeterminata perche'il numero di iterazioni non e' noto a priori.

+L'iterazione indeterminata permette il potere espressivo di una MdT

+

+### Iterazione determinata

+

+```

+for indice := inizio TO fine BY passo DO

+...

+END

+```

+

+Non si possono modificare: _indice, inizio, fine, passo_ all'interno del loop

+e'determinato (al momento dell'exec del ciclo) il numero di ripetizioni del ciclo

+Il potere espressivo e'minore rispetto all'iterazione indeterminata: non si possono esprimere computazioni che non terminano

+In molti ling (es il C) il _for_ non e'un costrutto di iterazione determinata (in C il for e' un while mascherato)

+

+#### Semantica del for

+

+Supponendo passo positivo:

+

+1. valuta le espressioni inizio e fine e ``congela’’ i valori ottenuti

+2. inizializza I con il valore di inizio;

+3. se I > fine termina l’esecuzione del for altrimenti

+ - si esegue corpo e si incrementa I del valore di passo;

+ - si torna a (3).

+

+In alcuni lig se il passo e'negativo si usa una sistassi diversa: downto (Pascal), reverse (ada)

+Per non fare istruzioni diverse, si puo usare un IC:

+IC = `(fine - inizio + passo) / passo`

+

+#### Cicli controllati numericamente

+

+I vari lig differiscono nei seguenti aspetti:

+

+1. possibilita' di **modificare gli indici**

+2. **Numero di iterazioni** (dove avviene il controllo `indice<fine`)

+3. incremento **negativo**

+4. **valore** di indice al termine del ciclo

+5. possibilita di salto dall'esterno all'interno

+

+(il do in fortran permette quasi tutto, con conseguenti problemi di leggibilita')

+

+Se in un ling c'e' solo il for allora esso non e'turing completo (manca la possibilita' di fare loop infiniti)

+Se considerassimo solo le exec finite e' possibile usare solo il for? NO -> funz di hackerman

+# Controllo

+

+# Controllo

+

+## Ricorsione

+

+Metodo alternativo all'iterazione.

+Una funz (procedura) e' ricorsiva se e'definita in termini di se stessa.

+

+```c

+int fatt (int n){

+ if (n<=1)

+ return 1;

+ else

+ return n* fatt(n-1);

+}

+```

+

+la definizione di una funzione ricorsiva e' analoga alla definizione induttiva di una funzione:

+

+- il valore F su un argomento e'definito in termini dei valori di F su argomenti piccoli.

+

+Nei programmi sono possibili definizioni non "corrette":

+

+```c

+int fie1(int n){

+ if (n==1) return fie1(1);

+}

+```

+

+ovvero `fie(1) = fie(1)`

+

+Nota: la ric e' possibile in qualisiasi ling che permetta:

+

+- funz (o procedure) che possono chiamare se stesse

+- gestione dinamica della mem (pila)

+

+### Ricorsione in coda

+

+Una chiamata di `g` in `f` si dice _chiamata in coda_ (o tail call) se `f` restituisce il val restituito da g senza ulteriore computazione.

+Quindi `f` e'tail recursive se contiene solo chiamate in coda:

+

+```

+function tail_rec (n: integer): integer

+begin … ; x:= tail_rec(n-1) end

+```

+

+Non ric in coda:

+

+```

+function non_tail_rec (n: integer): integer

+begin … ; x:= non_tail_rec(n-1); y:= g(x) end

+```

+

+> Nota:

+>

+> 1. **non server allocazione dinamica della mem con pila**: basta un unico RdA

+> 2. Piu' efficiente

+> 3. Possibile la generazione di codice tail-recursive usando continuation passing style

+

+##### Es. Caso del fattoriale

+

+Converto la seguente funz ric in funz ric in coda:

+

+```c

+int fatt(int n){

+ if (n<=1) return 1;

+ else return n* fattrc(n-1,n*res);

+}

+```

+

+Sol:

+

+```c

+int fattrc(int n, int res){

+ if (n<=1) return res;

+ else return fattrc(n-1,n*res);

+}

+```

+

+##### Altro es:

+

+Numeri di fibonacci

+Definzione induttiva:

+

+- fib(0) = 0

+- fib(1) = 1

+- fib(n) = fib(n-1) + fib(n-2)

+

+Versione con ric non in coda

+

+```c

+int fib(int n){

+ if (n==0)

+ return 1;

+ else

+ if(n==1)

+ return 1;

+ else

+ return fib(n-1) + fib(n-2);

+}

+```

+

+Complessita' lineare in tempo e spazio (O(n))

+

+Versione ric in coda:

+

+```c

+int fibrc(int n, int res1, int res2){

+ if (n==0)

+ return res2;

+ else

+ if(n==1)

+ return res2;

+ else

+ return fibrc(n-1,res2,res1+res2);

+}

+```

+

+Complessita':

+

+- in tempo lineare in n

+- in spazio costante (un solo RdA)

+# Sottoprogrammi

+

+Un linguaggio senza parametri puo'esistere? Si (es. assembly)

+

+## Astrazione

+

+- identificare proprietà importanti di cosa si vuole descrivere

+- concentrarsi sulle questioni rilevanti e ignorare le altre

+- cosa è rilevante dipende dallo scopo del progetto

+

+Voglio asseganare a un gruppo di istruzioni un nome e fare fare a questo gruppo di istruzioni delle op su dei paramentri che passo. Il codice diventa piu astratto e piu leggibile

+

+Nota: I LP sono essi stessi astrazioni del calcolatore sottostante

+

+Astrazione sul controllo e sui dati

+

+### Astrazione sul controllo

+

+Sono per es: sottoprogrammi, blocchi, parametri

+

+```

+double P (int x) {

+ double z;

+ /* CORPO DELLA FUNZIONE

+ return expr;

+}

+```

+

+

+

+### Astrazione del controllo

+

+Fornisce astrazione funzionale al progetto:

+

+- ogni componente fornisce servizi al suo ambiente

+- la sua astrazione descrive il comportamente esterno

+- e nasconde i dettagli interni necessari a produrlo

+

+Interazione limitata al comportamento esterno

+

+Comunicazione attraverso:

+

+- parametri

+- ambiente globale (ma distrugge l’astrazione)

+

+### Astrazione sui dati

+

+Tipo di dato = valori e operazioni (`integer = [-maxint..maxint]` e ` {+,-,*,div,mod}`)

+La rappresentazione (implementazione) dei dati delle operazioni inaccessibile all’utente, perché protetta da una capsula che la isola

+

+> Nota: impossibile nel linguaggi più vecchi

+>

+> - FORTRAN, Pascal, C

+

+### Parametri

+

+Terminologia

+

+- dichiarazione/definizione `int f (int n) {return n+1}` n si dice parametro formale

+ 

+

+Nota: Una funz comunica con il chiamante (return)

+

+#### Modalita' di passaggio dei parametri

+

+Per valore:

+

+- il val dell'attuale e'assegnato al formale, che si comporta come una var locale

+- pragmatica: main -> proc

+- attuale qualsiasi; modifiche al formale non passano all'attuale

+

+Per riferimento:

+

+- viene passato un riferimento (indirizzo) all'attuale; i riferimenti al formale sono referimenti all'attuale (aliasing)

+- pragmatica: main <-> proc

+- attuale: variabile; modifiche al formale passano all'attuale

+

+##### Es passaggio per valore:

+

+```c

+void foo (int x) { x = x+1; }

+ …

+ y = 1;

+ foo(y+1);

+```

+

+dopo foo y vale comunque 1.

+

+- Il formale x è una var locale (sulla pila)

+- Alla chiamata, l’attuale y+1 è valutato ed il valore è assegnato al formale x

+- Nessun legame tra x nel corpo di foo e y nel chiamante

+- Al ritorno da foo, x viene distrutto (tolto dalla pila)

+- Non è possibile trasmettere info da foo al chiamante mediante il parametro

+- Costoso per dati grandi: copia

+- Java, Scheme, Pascal (default), C e Java (unico modo);

+

+##### Es: passaggio per riferimento

+

+```c

+void foo (reference int x){ x = x+1;}

+ …

+ y = 1;

+ foo(y);

+```

+

+dopo foo y vale 2.

+

+- viene passato un riferimento (indirizzo; puntatore)

+- Il formale x è un alias di y

+- L’attuale deve essere un L-valore (“una variabile”)

+- Al ritorno da foo, viene distrutto il (solo) legame tra x e l’indirizzo di y

+- Trasmissione bidirezionale tra chiamante e chiamato

+- Efficiente nel passaggio, ma indirezione nel corpo

+- Pascal (var); in C simulato passando un puntatore…

+

+### Passaggio per risultato:

+

+simile al passaggio per riferimento.

+

+```c

+void foo (result int x) {x = 8;}

+ …

+ y = 1;

+ foo(y);

+```

+

+- Il formale x è una var locale (sulla pila)

+- Al ritorno da foo, il valore di x è assegnato all’attuale y

+- Nessun legame tra x nel corpo di foo e y nel chiamante

+- Al ritorno da foo, x viene distrutto (tolto dalla pila)

+- Non è possibile trasmettere info dal chiamante a foo mediante il parametro

+- Costoso per dati grandi: copia

+- Ada: out

+

+### Passaggio per valore/risultato:

+

+Insieme valore+risultato.

+Pragmatica: main ↔ proc

+

+Esiste(-va) in Algol-W:

+void foo (value-result int x)

+{ x = x+1; }

+…

+y = 8;

+foo(y);

+qui y vale 9

+• Il formale x è a tutti gli effetti una var locale (sulla pila)

+• Alla chiamata, il valore dell’attuale è assegnato al formale

+• Al ritorno, il valore del formale è assegnato all’attuale

+• Nessun legame tra x nel corpo di foo e y nel chiamante

+• Al ritorno da foo, x viene distrutto (tolto dalla pila)

+• Costoso per dati grandi: copia

+• Ada: in out (ma solo per dati piccoli; per dati grandi passa riferimento)

+

+### Valore e riferimento: morale

+

+Passaggio per valore:

+• semantica semplice: il corpo non ha necessità di conoscere come la procedura verrà chiamata (trasparenza referenziale)

+• implementazione abbastanza semplice

+• potenzialmente costoso il passaggio; efficiente il riferimento al parametro formale

+• necessità di altri meccanismi per comunicare main ← proc

+• Passaggio per riferimento:

+• semantica complessa; aliasing

+• implementazione semplice

+• efficiente il passaggio; un po’ più costoso il riferimento al parametro formale (un indiretto)

+

+### Valore, e non riferimento

+

+I vantaggi del passaggio per valore:

+

+- in particolare la trasparenza referenziale suggeriscono linguaggi con passaggio solo per valore

+ più meccanismi separati per ottenere il passaggio per

+ riferimento:

+ puntatori in C

+ variabili in modello a riferimento (tipi classe) in Jav

+

+### Passaggio per nome

+

+Regole di copia:

+

+- una chiamata alla procedura P e' la stessa cosa che eseguire il corpo di P dopo aver sostituito i parametri attuali al posto dei parametri formali

+

+La macro espansione viene realizzata in modo semanticamente corretto

+In algol-w era il default:

+

+```algol

+

+int y;

+void foo (name int x) {x= x + 1; }

+…

+y = 1;

+foo(y);

+```

+

+foo esegue `y=y+1`

+

+Caso piu complicato

+

+conflitto di variabili!

+Le due variabili `y` e `y` rossa sono diverse. fie incrementa l'attuale (y) attraverso il formale x e crea e distrugge la nuova y rossa

+

+Soluzione:

+Viene passata una coppia: `<exp, amb>`

+• `exp` è il parametro attuale (testo, non valutato)

+• `amb` è l’ambiente di valutazione (in scoping statico)

+• Ogni volta che il formale è usato, `exp` è valutata in `amb`

+

+

+

+Altro esempio:

+

+```java

+void fie (int x, int y) {

+ x = x+1;

+ y = 1;}

+…

+int i = 1;

+int[] A = new int[5];

+A[1]=4;

+fie (i,A[i]);

+```

+

+

+Passaggio per nome

+il corpo della proc viene riscritto al posto della chiamata e sostituisco le var con quelle in input

+

+La i e `A[i]` sono valutate nel main (il loro amb)

+

+quand arrivo al punto A[i] (ovvero y) = 1 visto che prima i e' stato incrementato allora andro' a modificare anche la i di A[i] quindi diventa A[2] = 1

+

+```

+f(nome x)

+ y = x

+ y = x

+ y = x

+

+z = 1

+f(z++)

+```

+

+con passaggio per nome la sostituzione viene fatta ogni volta che viene trovato il param corrispondente

+

+quindi diventa:

+

+```

+f(nome x)

+ y = z++

+ y = z++

+ y = z++

+

+z = 1

+f(z++)

+```

+

+quindi y diventa 4 (o 3, in base a quando viene fatto z++)

+

+#### Implementazione passaggio per nome

+

+Come passare la coppia <exp,env>?

+– un puntatore al testo di exp

+– un puntatore di catena statica (sullo stack) al record di

+attivazione del blocco di chiamata

+

+cioè una chiusura (perché chiude un’espressione: elimina le sue variabili libere legandole nell’ ambiente del chiamante)

+

+Le chiusure servono a passare funzioni come argomenti ad altre

+procedure

+Parametro per nome = funzione nascosta senza argomenti che valuta il parametro nell’ambiente del chiamante (un thunk, nel gergo Algol)

+

+

+

+### Funzioni di ordine superiore

+

+Alcuni linguaggi permettono di:

+– passare funzioni come argomenti di procedure

+– restituire funzioni come risultato di procedure

+• Entrambi i casi: come gestire l’ambiente della funzione ?

+• Caso più semplice

+– Funzioni come argomento

+– Occorre un puntatore al record di attivazione all’interno della pila: passa una chiusura !

+• Caso più complicato

+– Funzione restituita da una chiamata di procedura

+– Occorre mantenere il record di attivazione della funzione

+restituita: disciplina a pila non funziona!!

+

+

+

+in scope dinamico la x dentro la f puo velere 7 (se pero si valuta lo scope di f quando viene chiamata e non quando viene passata) quindi guardo il suo ambiente quando viene chiamata non passata. Questa regola si chiama regola di shallow binding

+Altrimenti (nel caso in cui io valuti l'ambiente della funz quando essa viene passata e non quand o viene chiamata), ovvero alla riga `g(f)` quindi la x vale 5. Questa regola si chiama deep binding

+

+#### i funarg problems: downward

+

+Quando una procedura viene passata come parametro si crea un riferimento tra un nome (h) e una procedura (f)

+

+

+

+```

+nt x=4; int z=0;

+int f (int y){

+return x*y;}

+void g ( int h(int n) ) {

+int x;

+x = 7;

+z = h(3) + x ;

+end;

+…

+{int x = 5;

+g(f);

+}

+```

+

+deep binding: quando nel corpo di g vado ad usare f (quando andro a chiamare f da dentro g) essa avra' delle var non locali (x) che valuto nell'ambiente che c'e al momento della chiamata della funz alla quale f e' stata passata

+Ricapitolando: il bind viene fatto quando g chiama f

+shallow binding: il bind viene valutato dentro g quando f viene eseguito

+

+

+

+

+

+#### Chiusure

+

+Passare dinamicamente sia il legame col codice della funzione, che il suo ambiente non locale,cioè una chiusura `<code, env>`

+Alla chiamata di una procedura passata per parametro

+– alloca (come sempre) il record di attivazione

+– prendi il puntatore di catena statica dalla chiusura

+

+

+

+#### Riassumendo: parametri funzioni (e per nome)

+

+Chiusure per mantenere puntatore all’ambiente statico del corpo di una funzione

+

+Alla chiamata, il puntatore di catena statica determinato mediante la chiusura

+

+Tutti i puntatori di catena statica puntano sempre indietro nella pila

+– record di attivazione possono essere “saltati” per accedere a var non locali

+– de-allocazione dei record di attivazione secondo stretta politica a pila (lifo: last-in-first-out)

+

+### Scope dinamico: implementazione

+

+Shallow binding:

+– non necessita di alcuna attenzione

+• per accedere a x, risali la pila

+• uso delle strutture dati solite (A-list, CRT)

+

+Deep binding

+– usa necessariamente qualche forma di chiusura per “congelare” uno scope da riattivare più tardi

+

+### Deep e shallow binding con scope statico

+

+

+

+#### Esercizio:

+

+

+

+#### Esercizio in classe

+

+```

+{void foo (int f(), int n){

+ int m = 10;

+ int fie(){ write (n,m)}

+ if (n==0) f();

+ else {m=30;

+ foo(fie,0);

+ }

+ }

+ int g(){

+ write(10);

+ }

+ foo(g,1);

+}

+```

+

+si dica cosa stampa in frammento con shallow e deep bindig

+deep binding:

+

+- n=1 e m=30

+

+shallow binding:

+

+- Es: spiegare vantaggi e svantaggi scope statico e scope dinamico

+ scope statico: vantaggio: maggiore chiarezza del codice (trasparenza referenziale) e la stessa funz chiamata in tempi diversi con stessi param non cambiano il risultato

+ svantaggi: difficile da implementare (catena)

+ scope dinamico: impl facile, svantaggio: progr molto meno comprensibili

+

+#### upward funarg problema

+

+Alcuni linguaggi (eg funzionali) permettono di restituire una funzione

+Se la funzione ha variabili locali queste devono sopravvivere indipendentemente dalla struttura a pila: hanno vita indefinitamente lunga

+

+

+

+

+

+(la pila va dall'alto verso il basso)

+

+**Morale: funzioni come risultato**

+• Uso delle chiusure, ma…

+• I record di attivazione persistono indefinitamente

+– perdita proprietà della pila (lifo)

+• Come implementare la “pila” in questo caso:

+– non deallocare esplicitamente

+– record di attivazione sullo heap

+– le catene statica e dinamica collegano i record

+– invoca il garbage collector quando necessario

+

+domande orale:

+quasi mai esercizi

+domande sui concetti del corso es per verdere se siamo in geado di esporre gli arg tecnici es

+cos'e un tipo di dato, cos'e una variabile, siegami in dettaglio come funz l'impl del meccanismo di deep binding con le chiusure

+

+differenza tra meccanismo di invocazione di un mentodo e chiamata di funz in un ling imperativo.

+i ling oop in cosa sono meglio dei ling normali (procedurali?)

+---

+title: Algebra dei Tipi

+---

+

+# Sistemi dei tipi

+

+Ogni linguaggio di programmazione ha un proprio **sistema di tipi** cioe' info e regole che governano i tipi e i loro valori, chiamati abitanti (inhabitants) del tipo

+

+## Tipi base (primitivi)

+

+Sono tutti i tipi che definiscono i val denotabili del linguaggio. Es. 42, 3.14 'A' (int, float, char).

+Il modo in cui caratterizziamo 42 e int dipende dal ling che stiamo usando, in java si usano 4 byte per rappresentare un int (corrisponde a tutti i num interi da $-2^{32}$ a $2^{31}-1)

+In rust dovremmo specificare ulteriormete il tipo di intero che ci intererssa memorizzare (i32, u32)

+

+### Tipo Unit (vs Void)

+

+L'unico abitante del tipo Unit e' l'unita' singoletto (rapp anche come ()) e di solito e' associato a op il cui tipo di ritorno non e' utilizzabile (es. quando devo inviare cose, stampare qualcosa a schermo) devo avvisare che ho finito, lo faccio ritornando unit.

+

+Linguaggi come Java o C hanno un concetto simile all'unita col tipo unit, il `void` che pero' presenta differenze con unit. Non possiamo ne ottenere ne passare void (mentre con unit si). Java ha dovuto mettere un output a void (ritorna null).

+

+### Booleani

+

+Valori: solo true e false

+

+operazioni: principali operazioni logiche, come la congiunzione (&), la disgiunzione (|), la negazione (!), l'uguaglianza (==)

+

+In c originale non c'erano

+

+### Tipi di caratteri

+

+valori: insieme di codici di caratteri (es. ascii, unicode)

+operazioni: =, ><

+

+### Tipi Interi

+

+val: sottoinsieme finito di numeri interi, fissato al momento della definizione del linguaggio

+

+operazioni:

+

+### Reali

+

+valori: un sottoinsime finito tra i num reali, tramite rappresentazione a virgola mobile e fissa

+

+- i num a virgola fissa riservano bit specifici per gli interi e decimali. A virgola mobile no.

+

+### Enumeration types

+

+Un tipo di enumerazione consiste in un iniseme finito di costanti, ciascuna caratterizzata da yn proprio nome. C, rust, java forniscono la stessa sintassi ad es:

+

+```c

+enum rogueOne {Jean, Cassian, A, B, C }

+```

+

+introducono un nuovo tipo chiamato rogueOne costituito da un insieme di 5 elementi, ciascuno con un proprio nome.Le operazioni disponibili sugli enum consistono in

+confronti e in un meccanismo per ottenere tutti i valori o passare da uno all'altro. Da un punto

+di vista pragmatico, gli enum presentano due vantaggi: 1) aiutano la leggibilità, poiché i nomi dei

+valori costituiscono una chiara forma di auto-documentazione del programma e 2) permettono

+al controllo di tipo di verificare che una variabile con enumerazione assuma solo i valori corretti.

+

+Non tutti i linguaggi integrano gli enum in modo sicuro, ad esempio in C la scrittura sopra

+è uno zucchero sintattico per

+

+```c

+typedef int RogueOne; const RogueOne Jyn=0, Cassian=1, .....;

+```

+

+che equipara gli interi ai RogueOne e impedisce di distinguerli (e di verificarne la correttezza).

+

+### Extensional vs Intensional types

+

+Gli interi (e i float, i chars, ...) rispetto agli enum hanno una differenza importante: l'utente specifica gli enum in modo estensionale, cioè elencando tutti i possibili abitanti di quel tipo. Al contrario, i linguaggi specificano gli interi, i float e così via in modo intensionale, cioè mediante predicati che definiscono la loro appartenenza ad alcuni domini di valori possibili (ad esempio, numeri interi a 32 bit, numeri in virgola mobile, caratteri UNICODE).

+

+Si usano sistemi intesionali quando si dispone di un insieme definito di prop che indentificanop solo gli abitanti (val validi) del tipo che sto definendo (vantaggio: risparmio di mem)

+

+Estensionale quando e'piu efficiente (per spazio e computazione) specificare gli a bitanti del tipo o non esiste un iniseme chiaro di regole che li definiscono

+

+## Tipi composti

+

+Gli enum sono kinds (possono creare tipi) mentre i tipi sono es arrayInt, int, char. Gli enum devono essere istanziati per diventare tipi.

+Possiamo creare nuovi tipi componendo quelli di base.

+Nelle enumerazioni di C, abbiamo creato insiemi di elementi denominati, che corrispondono a numeri interi, ma sono possibili altre strutture, tra cui le più basilari sono: array, insiemi e puntatori.

+

+### Array

+

+Anche gli array sono kinds (non esiste il tipo array ma esiste il tipo array di interi, float ecc). Un array denota un insieme di elementi di un certo tipo, ciascuno indicizzato da almeno una ** chiave identificativa** di uyn certo tipo (quando si usano 2 o piu chaivi si parla di array multidimensionali).

+La nozione piu comune di array assume chiavi come num interi non negativi all'interno di un intervallo [0-n] per n+1 elementi. Altri tipi di array (mappe) permettono di creare **array associativi**, permenttono all' utente di fissare sia il tipo delle chiavi che quello degli elementi.

+

+**tabella sintassi dichiarazione int in C, java e rust**

+int x[3] int[] x let x: [i32;3]

+x[0] = 0 // posso farlo solo in c, in java devo prima istanziarlo

+int x[3] = {0,0,0} x = new int[3] x = [0,0,0]

+

+Sia il C che Rust fissano nella dichiarazione del tipo la dimensione dell'array (3), mentre Java astrae da questo e lascia che sia l'inizializzazione a definire la dimensione dell'array (ne parleremo in seguito).

+La maggior parte dei linguaggi (tra cui C, Java e Rust) estendono le dichiarazioni di array lineari a quelle a più chiavi

+int x[10][10] int[][] x let x: [[i32;10];10]

+

+In C posso fare il lookup di una val di una cella di un array che ho appena creato ma a cui non ho ancora associato un val (leggo celle di memoria scritte da chissa' chi, possono contenere info sensibili)

+L'op piu semplice da fare su un arrau e' la selezione di un elem tramite il suo indice. La notazione e' `a[e]` dove `a` e' la var di tipo array e `e` e' l'espressione. Per array multidimensionali sono `a[e][e][e]` o `a[e,e,e]` (per ling che hanno sia array multidimensionali che array di array). Altre op (su array di interi) sono: assegnazione (=), confronti (==, <,>) e le op aritmetiche

+Poiché conoscono il tipo di indice degli array, i linguaggi safe verificano che ogni accesso a un elemento dell'array avvenga davvero entro i suoi “limiti” (si fa solo a runtime).

+

+Un array viene solitamente memorizzato in una porzione contigua di memoria. Per un array monodimensionale, l'allocazione segue l'ordine degli indici. Per gli array multidimensionali, esistono principalmente due tecniche, chiamate ordine di riga (row major) e ordine di colonna (column major).

+

+

+Nell'ordine di riga, due elementi sono contigui se differiscono di uno nell'ultimo indice. Nell'ordine per colonna, due elementi sono contigui se differiscono di uno nel primo indice. L'ordine di riga è un po' più comune di quello per colonna, soprattutto perché gli accessi per riga sono più frequenti di quelli per colonna. In generale, il principio di località del caricamento in funzione dei cache-miss favorisce gli algoritmi che esplorano gli array per righe con ordine di riga e viceversa per l’ordine di colonna.

+

+#### Dimensione array

+

+Il numero di dimensioni e i loro intervalli determinano la forma di un array. Un aspetto importante della definizione di un linguaggio è decidere se e quando fissare la forma degli array. Se la forma è fissa, possiamo decidere di definirla in fase di compilazione (per i linguaggi compilati, come in C e Rust) o quando elaboriamo la dichiarazione (a tempo di esecuzione). In alternativa, possiamo avere array dinamici, la cui forma è determinata e cambia in fase di esecuzione (come in Java).

+

+

+In un array statico conosciamo la dimensione necessaria per memorizzare l'array (l'offset tra il primo e l'ultimo elemento dell'array), quindi l'accesso a un elemento dell'array è simile all'accesso a variabili di tipo scalare (salvo alcuni calcoli necessari, ad esempio, quando si accede ad array multidimensionali).

+

+Se decidiamo di definire l'array quando elaboriamo la sua dichiarazione, conosceremo la sua forma (fissa) nel momento in cui il controllo raggiunge la dichiarazione dell'array. Un esempio di questo tipo è se la dimensione dipende dal valore di una variabile. Possiamo allocare l'array nello stack frame del blocco che ne contiene la definizione. Tuttavia, poiché conosciamo la dimensione dell'array solo quando carichiamo il frame, non possiamo preallocare in modo sicuro lo spazio nello stack: una stima errata sprecherebbe memoria o si sovrapporrebbe ad altre variabili statiche. Per ovviare a questo problema, si utilizza l'heap e si memorizza nel frame il puntatore all'inizio della regione di memoria. Il descrittore di tale array prende il nome di dope vector, utilizzato anche nel caso di array dinamici (con alcuni elementi aggiuntivi nel dope vector per tenere traccia del suo stato).

+

+Lo stack frame ha molte piu cose (devo tenere conto di una var dimensione ecc)

+

+### Tipi insieme

+

+Struttura di dati senza ordine con valori unici dello stesso tipo.

+

+Le operazioni possibili sugli insiemi includono il **test di inclusione** e le operazioni di manipolazione degli insiemi: **unione, intersezione, differenza e complemento**.

+

+L'estrazione e' un op strana perche' sono liste senza ordine quindi devo pescare a caso i val. Il caso in informatica non esiste quindi chi ha il seed dell'estrazione sa predire l'estrazione successiva.

+

+#### Rappresentazione in memoria di un insieme

+

+Un modo efficiente per rappresentare un insieme è un array di bit di lunghezza pari alla cardinalità del tipo di base (es set di elementi da 0 a 7, cardinalita' 8). Questo array è chiamato **array caratteristico** e, in esso, il bit -esimo indica se l’elemento -esimo del tipo base (dato un ordinamento standard) appartiene all'insieme. Questa rappresentazione permette di eseguire in modo efficiente le operazioni sugli insiemi (operazioni bit-a-bit sulla macchina fisica), ma non è adatta a grandi sottoinsiemi di tipi base. Per ovviare a questo problema, i linguaggi spesso limitano i tipi che si possono usare come tipi base di un insieme oppure scelgono rappresentazioni alternative, ad esempio tramite tabelle hash, bilanciando velocità e occupazione di memoria (perche' se ho un ash come tipo base ho campi molto grandi ma facili da trovare)

+

+Esempio array caratteristico:

+Immagina che il tuo tipo base siano i numeri da 0 a 7 (cardinalità = 8). Il linguaggio crea un array di 8 bit.

+Se il tuo insieme è {1, 4, 5}, l'array sarà:

+Valore (Indice i) 0 1 2 3 4 5 6 7

+Bit (1=Presente, 0=Assente) 0 1 0 0 0 0

+

+Fare l'unione o l'intersezione tra due insiemi diventa una semplice operazione bit-a-bit (OR, AND) a livello di processore. È istantaneo.

+I l limite? Se il tipo base fosse "Tutti i numeri interi a 32 bit". L'array dovrebbe avere 2^{32} bit (circa 512 Megabyte di memoria) per un singolo insieme, anche se contiene solo tre numeri! Uno spreco enorme.

+

+Esempio con tabelle Hash (Il workaround moderno)

+

+Quando il tipo base è grande (come stringhe, o numeri interi generici), i linguaggi moderni (come Python, Java, C#) abbandonano l'array di bit e usano le Tabelle Hash.

+

+Una piccola correzione al tuo ultimo appunto: Non è che hai un "hash come tipo base", ma usi una Tabella Hash come struttura dati sottostante.

+In pratica, passi il tuo valore (es. la stringa "Ciao") a una funzione di hash, che lo trasforma in un numero. Quel numero diventa l'indirizzo di memoria dove salvare il dato.

+

+ Il compromesso: Occupa un po' più di memoria rispetto all'array di bit puro ed è impercettibilmente più lenta nelle operazioni logiche, ma risolve il problema dello spreco di spazio, permettendoti di creare insiemi di qualsiasi tipo di dato senza far esplodere la RAM.

+---

+title: Introduzione ai Tipi

+---

+

+# Introduzione ai Tipi

+

+Una definizione plausibile di sistema di tipi in informatica è:

+

+```

+Un metodo sintattico praticabile per dimostrare

+l'assenza di determinati comportamenti del

+programma, fatto classificando le unità sintattiche in

+base ai tipi di valore che assumono.

+```

+

+### Type-checking

+

+Il vantaggio più famoso dei tipi è il type-checking, cioè la possibilità di usare i tipi per rilevare errori di programmazione.

+

+Il type-checking e' una specie di dim di un teorema. Prende le dichiarazioni dei tipi come def di teoremi o regole su quello che succede nel programma. Controllando ogni passaggio del programma (staticamente) se non ho errori la prova ha avuto successo, altrimenti errore.

+

+### Safety

+

+la “safety” si riferisce alla capacità di un linguaggio di garantire l'integrità delle sue astrazioni (ovvero effettua i controlli sulle sue astrazioni). I linguaggi “safe” sono anche detti a tipizzazione forte o strongly typed (e quelli non sicuri a tipizzazione debole o weakly typed).

+

+Un ling strongly typed significa che le astrazioni sono garantite da linguaggio

+Il c e' weakly typed es. negli array posso accedere a pos che non fanno parte degli array (es accedo alla pos 5 di un array di 4 elem)

+In java (strongly typed) ha controllo su enum e controllo su array (out of bound exception)

+typescript e' strongly typed

+Un ling strongly typed ti impedisce di fare cose, uno weakly typed no (meno)

+

+I tipi possono contribuire a migliorare l'efficienza dei programmi. Nei linguaggi safe, i tipi aiutano a migliorare l'efficienza eliminando molti dei controlli dinamici per garantire la sicurezza. I moderni compilatori ad alte prestazioni si basano molto sulle informazioni raccolte dal type-checker per ottimizzare la generazione del codice.

+

+Nota: in java un bool occupa 2 byte (colpa della jvm)

+

+## Dynamic vs Static Typing

+

+Un ling e' tipato **staticamente** se possiamo controllare i tipi sul testo del programma, senza doverlo eseguire (es. in fase di compilazione). Il compilatore puo' eliminare le annotazioni di tipo (e i relativi controlli) dal codice generato (perche' tanto sono giusti e quindi non devono essere controllati a runtime).

+

+Si parla di linguaggi tipati **dinamicamente** quando il controllo dei tipi avviene durante l'esecuzione del programma. In particolare, il controllo dinamico dei tipi richiede che ogni valore abbia un descrittore di esecuzione che ne specifichi il tipo e che, a ogni operazione, il runtime verifichi che il programma esegua operazioni solo su operandi del tipo corretto.

+

+## Manifest vs Inferred typing

+

+La tipizzazione statica o dinamica riguarda il momento in cui un ling (interpretato o compilato) esegue il controllo dei tipi. Il tipaggio manifesto o inferito determina la quantita' di informazioni sui tipi che il programma deve inserire nei suoi programmi.

+Un linguaggio con **manifest typing** richiede che il programma annoti tutti i tipi di variabili e operazioni. Un linguaggio con inferred typing non ha bisogno di annotazioni, in quanto dispone di algoritmi che deducono i tipi dal contesto.

+

+Il **tipaggio manifesto e inferito sono uno spettro** determinato da fattori ergonomici e algoritmici. Ad esempio,leggendo il programma x=5 noi (come programmatori) possiamo dedurre che il tipo di x potrebbe essere intero. il bilanciamento tra tipi manifesti e tipi inferiti non è una decisione netta e riguarda il bilanciamento tra supporto/impegno che un linguaggio offre/richiede ai programmatori.

+

+## Dynamic vs Static Typing

+

+I linguaggi a tipaggio dinamico non sono per forza interpretati.

+Quindi, la richiesta di scegliere tra un linguaggio a tipaggio dinamico e uno a tipaggio statico non riguarda la quantità di informazioni che i programmatori devono fornire sui tipi (manifesti o inferiti) o se i programmi sono interpretati o compilati (implementazione). Invece, i fattori principali che possono orientare la scelta tra i due approcci sono la correttezza, le prestazioni e l'espressività del programma.

+

+Il tipaggio statico significa trovare gli errori prima di eseguire il programma. Questo elimina la necessità di annotare i termini e di eseguire controlli a tempo di esecuzione e permette alcune ottimizzazioni, aumentando le prestazioni. Tuttavia, i linguaggi a tipaggio statico hanno un “difetto” comune: a seconda dell'espressività dei tipi e dell'accuratezza dell'algoritmo di type-checking, possono rifiutare programmi che verrebbero eseguiti correttamente (ad esempio, il codice sulla destra). Ciò è dovuto all'indecidibilità dei programmi (terminazione), che rende impossibile sapere quali rami verranno eseguiti o meno e costringe il type- checking a considerare tutti i possibili stati di calcolo.

+

+```

+int x

+if(e) x=“A”

+else x = 5

+```

+

+se `e` e' falsa, questo codice verrebbe eseguito correttamente ma il controllo statico boccia questa implementazione.

+# Architettura dei sistemi Operativi

+

+descrive quali sono le varie componenti del so e come queste sono collegate tra loro

+

+L'architettura dei so da diversi punti di vista

+

+- servizi forniti (visione utente non tanto la persona quanto i programmi)

+- interfaccia di sistema (visione programmatore)

+- componenti di sistema (visione progettista so)

+

+## Componenti di un sistema operativo

+

+ Gestione dei processi

+ Gestione della memoria principale: ram o mem interna processore

+ Gestione della memoria secondaria: dischi

+ Gestione file system: stato che si colloca al disopra della mem secondaria e ci permette di vedere le cose nella mem secondaria

+ Gestione dei dispositivi di I/O

+ Supporto multiuser: moduli all'interno del so che creano l'astrazione multiutente (sono info di corredo che vengono aggiunte per creare multiutenti)

+ Networking

+ Inter Process Communication (IPC)

+

+### Gestione processi

+

+- un processo e' un programma in esecuzione (l'attivita di un programma in esecuzione).

+- il sistema operativo e' responsabile delle seguenti attivita'

+ - creazione e terminazione dei processi

+ - sospensione e riattivazione dei processi

+ - gestione deadlock

+ - comunicazione tra processi

+ - sincronizzazione tra processi

+

+### Memoria Principale

+

+- e' un array di byte indirizzabili singolarmente

+- ci sono istruzioni per accedere a un singolo byte o di piu fino al (non ho capito) es. un processore da x64 puo accedere a 1-16-64 byte in blocchi

+- è un deposito di dati facilmente accessibile alla CPU (econdiviso con i controller dei dispositivi di I/O se DMA)

+

+il sistema operativo e' responsabile delle seguenti attivita:

+

+- tenere traccia di quali parti della mem sono usate da chi

+- decidere quali processi caricare quando diventa disponibile spazio in mem

+- allocare e deallocare lo spazio di memoria quando necessario

+- usare mem secondaria per ampliare la mem principale (vitual memory, swap) se una pagina non viene usata da un po viene messa in mem secondaria

+

+### Memoria Secondaria

+

+Poiché la memoria principale è volatile e troppo piccola per

+contenere tutti i dati e tutti i programmi in modo

+permanente, un computer è dotato di memoria secondaria

+ In generale, la memoria secondaria è data da hard disk,

+dischi ottici, dischi allo stato solido, etc.

+Si accede a blocchi (nella mem primaria si accede a byte)

+

+Il sistema operativo e' responsabile delle seguenti attivita riguardanti la gestione della memoria secondaria:

+

+- gestione partizionamento

+- gestione dell'accesso efficiente e affidabile (RAID) Nota: raid viene usato per velocita'. Si usa per sparpagliare i dati su vari dischi cosi da ridurre il tempo di ritardo medio delle richieste. Facendo raid semplice si va piu veloci come performance ma si ottiene un sistema piu fragile i dischi si rompono prima

+- ordinamento efficiente delle richieste (disk scheduling)

+

+### Gestione dell'I/O

+

+Un interfaccia per la gestione dei device driver

+Un insieme di driver per dispositivi hw specifici

+Un sistema di gestione buffer per il caching delle informazioni

+

+Per ogni op di io un dirver va in funzione due volte (alla fine dell'op di io quando deve essere inviato l'interrrupt e per la richiesta )

+

+### Gestione del file system

+

+Un file e' l'astrazione informatica di un archivio di dati

+(il concetto di file e' indipendente dal media sul quale viene memorizzato)

+Un file system e' composto da un insieme di file

+un fs e' anche quello contenuto in una chiavetta (quando si fa mount viene visto il file system della chiavetta)

+Il sistema operativo e' responsabile delle seguenti attivita':

+

+- creazione e cancellazione file

+- creazione e cancellazione di directory

+- manipolazione di file e directory

+- codifica dei file system su una sequenza di blocchi

+

+### Supporto multiuser - protezione

+

+Il termine protezione si riferisce al meccanismo per controllare gli accessi dei processi alle risorse del sistema e degli utenti

+Il meccanismo di protezione sw deve:

+

+- gestire l'identita' del proprietario del processo (uid gid)

+- gestire chi può fare cosa (per ogni utente per ogni risorsa memorizzare cosa puo’ essere fatto e cosa no)

+- Fornire un meccanismo di attuazione della protezione

+

+### Networking

+

+- consente

+ - di fare comunicare processi in esecuzione su piu elaboratori

+ - di condividere risorse

+- quali servizi

+ - protocolli di comunicazione a basso livello

+ - ip

+ - tcp,udp

+- servizi di comunicazione ad alto livello

+ - file system distribuiti (nfs,smb)

+

+## Architettura dei sistemi operativi - struttura del programma sistema operativo

+

+### Sommario

+

+ Sistemi con struttura semplice

+ Sistemi con struttura a strati

+ Microkernel

+ Macchine virtuali

+ Progettazione di un sistema operativo

+

+Ora vediamo come le componenti del so sono collegate tra loro

+

+progettazione di un so:

+sistemi molto efficienti sono poco modulari

+ sistemi molto modulari sono meno efficienti

+

+### Struttura dei so

+

+Divisi in due grandi famiglie

+

+- struttra semplice

+- struttura a strati

+

+Sistemi a struttura semplice (o senza struttura)

+

+- in alcuni casi sono so che non hanno struttura progettata a priori

+- possono essere descritti come una collezione di procedure, ognuna delle quali puo chiamaer altre procedure

+- tipicamente sono so semplici e limitati

+

+MS-DOS Free-DOS

+

+

+MS-DOS

+

+- Commenti

+  le interfacce e i livelli di funzionalità non sono ben separati

+  le applicazioni possono accedere direttamente alle routine

+ di base per fare I/O

+  come conseguenza, un programma sbagliato (o "maligno")

+ può mandare in crash l'intero sistema

+- Motivazioni:

+  i progettisti di MS-DOS erano legati all'hardware dell'epoca

+  8086, 8088, 80286 non avevano la modalità protetta (kernel)

+

+nessun controllo di accessi in memoria (l'uso piu comune sel tsr era quello di inserire dei virus, lol)

+I giochi cercavano di bypassare il so e accedere direttamente alle risorse (es gpu)

+Un errore del programma (visto che non cerano controllo di accessi in memoria) poteva causare il crash del sistema

+

+UNIX

+Le prime versioni facevano un po cagare

+diviso in due parti (kernel e programmi di sistema)

+Il kernel e' delimitato:

+

+- in basso dall'hw

+- in alto dal livello delle system call

+

+Motivazioni

+

+- anche Unix inizialmente fu limitato dalle limitazioni

+ hardware...

+- ... ma ha un approccio comunque più strutturato

+

+

+

+### Sistemi con struttura dati a strati

+

+Il so e' strutturato tramite un insieme di strati (layer)

+

+Ogni strato:

+e' basato sugli strati inferiori

+offre servizi agli strati superiori

+

+Motivazioni:

+il vantaggio principale e'la modularita:

+

+- encapsulation e data hiding

+- abstract data types

+ Vengono semplificate le frasi di implementazione, debugging e ristrutturazione del sistema

+

+

+Esempi:

+

+The O.S. (Dijkstra) 5) Programmi utente 4) Gestione I/O 3) Console device/driver 2) Memory management

+

+1. CPU Scheduling

+2. Hardware

+

+Venus os 6) Programmi utente 5) Device driver e scheduler 4) Memoria virtuale 3) Canali di I/O 2) CPU Scheduling

+

+1. Interprete di istruzioni

+2. Hardware

+

+Problema dei sistemi con struttura a strati

+

+- tendono a essere meno efficienti (ogni stato tende ad aggiungere overhead)

+- occorre studiare accuratamente la struttura dei layer

+ - le funzionalita previste al layer N devono essere implementate utilizzando esclusivamente i servizi dei livelli inferiori

+- in alcuni casi questa limitazione puo essere difficile da superare

+- esempio: meccanismi di swapping di memoria

+ - Win: swap area è un file in memoria

+ - Linux: swap area ha una partizione dedicata

+

+risultato: si tende a trovare un compromesso tra i due mondi

+

+OS/2

+

+Nota: scrivi due righe su window subsystem for linux

+Computer HW/SW architecture (Myers)

+Grafico di myers

+ISA e'il codice macchina per fare le op macchina (instruction set architucture)

+Alla fine l'hw e' linguaggio

+

+