Linguaggi formali

● Presenti in tutte le applicazioni (linguaggi, interazioni uomo macchina ecc)

● Fondamentali nei software, paradigmatici nella teoria → Appartenenza

Alfabeti e stringhe:
● Alfabeto Σ → insieme di simboli
● Stringa s → Insieme di simboli di Σ
○ s ∈ Σ∗¿ → Insieme di tutte le stringhe
○ ε → stringa vuota
○ |s| → lunghezza della stringa s
● Linguaggio L ⊆ Σ∗¿ (simbolo ⊆=¿sottoinsieme)
○ Sottoinsieme di tutte le stringhe possibili
○ Grammatica: Insieme di regole formali per formare stringhe corrette
Concatenazioni di stringhe
● Operazione di concatenazione ∙
○ Proprietà associativa ( x ∙ y )∙ z=x ∙( y ∙ z)
○ Non commutativa x ∙ y ≠ y ∙ x
○ Σ∗¿ chiuso rispetto a ∙ :Σ∗x Σ∗→ Σ∗¿
● Potenza → x n=x ∙ x (n volte)
● Elemento neutro ε → x ∙ ε =x

Definizione di linguaggi
● Approccio algebrico: linguaggio costruito a partire da linguaggi più elementari, con
operazioni sui linguaggi
● Approccio generativo: grammatica, regole per la generazione di stringhe,
appartenente al linguaggio
● Approccio riconoscitivo: macchina astratta o algoritmo di riconoscimento, per
decidere se una stringa appartiene o no a un linguaggio
Operazioni sui linguaggi
L1 ed L2 linguaggi su Σ* (due insiemi di stringhe)
● Unione: L1 ∪ L2 = {x ∈ Σ* : x ∈ L1 ∨ x ∈ L2}
● Intersezione: L1 ∩ L2 = {x ∈ Σ* : x ∈ L1 ∧ x ∈ L2}
● Complementazione: ̅L1 = {x ∈ Σ* : x ∉ L1}
Concatenazione di linguaggi
Concatenazione o prodotto:
● L1•L2 = {x ∈ Σ* : x = x1•x2, x1 ∈ L1, x2 ∈ L2}
○ Es. L1 = {ab, bb}; L2 = {aa, ab};
○ L1 • L2 = {abaa, abab, bbaa, bbab}
● Potenza: Ln = L • Ln-1, n≥1; L0 = {ε} per convenzione
● Concatenazione di‌n stringhe qualsiasi di L
○ Es. L = {ab, bb}; L2 = {abab, abbb, bbab, bbbb}
● Stella di Kleene: L* = ∪ Ln, n = 0..∞
○ Concatenazione arbitraria di‌stringhe di L

Espressioni regolari
Dato un alfabeto Σ, chiamiamo espressione regolare una stringa r sull'alfabeto Σ ∪ {+, *, (, ),
•, Ø} t.c.:
● r = Ø: linguaggio vuoto; oppure
● r ∈ Σ: linguaggio con un solo simbolo; oppure
● r = s + t: unione dei linguaggi L(s), L(t); oppure
● r = s • t: concatenazione dei linguaggi L(s), L(t); oppure
● r = s*: chiusura del linguaggio L(s)
(con s e t espressioni regolari; simbolo • spesso implicito)
Linguaggi regolari: rappresentabili con espressioni regolari (“regex”)

Regex
● Concatenazione di caratteri: goal
● Unione tra espressioni (opzione): one|two|three
● Un car. da un insieme (o no): [a-z], [^a-z0-9]
● Un carattere qualsiasi: defin.tely
● Ripetizioni (0+, 1+, 0-1): goo*al, go+al, goo?al
● Sottoespressione: (left right )*halt
Classi di caratteri
● [...] per includere uno qualsiasi dei caratteri in parentesi
○ Singoli caratteri o intervalli di caratteri adiacenti
○ [A-Z] = qualsiasi lettera maiuscola
○ [a-zABC] = qualsiasi lettera minuscola oppure A, B, o C
● [^...] per escludere uno qualsiasi dei caratteri in parentesi
○ [^0-9] = qualsiasi carattere non numerico
● Simboli speciali per identificare classi di caratteri
○ \d = numerico, ossia [0-9]
○ \s = [ \t\r\n\f]
○ \w = [0-9a-zA-Z_]
○ \D = non numerico, ossia [^0-9] (ecc.)

Caratteri speciali
● . per un carattere qualsiasi
○ A.B riconosce la stringa AoB, AwB, AOB ecc.
● \ escape, per segnalare sequenze speciali o considerare caratteri speciali come
normali
○ \? cerca il ?
● ^ corrisponde all'inizio del testo
● $ corrisponde alla fine del testo
● | per alternativa tra due espressioni (unione)
○ A|B = carattere A o carattere B
● (...) per raggruppare sotto-espressioni
○ ga(zz|tt)a trova sia gazza che gatta
Ripetizioni
● {...} per specificare il numero di ripetizioni
○ \d{3,5} sequenze di almeno tre cifre, al massimo cinque
● * zero o più occorrenze di un’espressione
○ (ab)* riconosce ab, abab, la stringa vuota, ma non riconosce abba
● + una o più occorrenze
 ○ (ab)+ non riconosce la stringa vuota
● ? zero o al più una occorrenza (parte opzionale)
○ (ab)? riconosce ab ma non abab

Grammatiche di Chomsky
● Grammatica G = ¿ V t , V N , P , S >¿
○ V T → Alfabeto finito di simboli terminali
○ V N → Simboli non terminali
○ V =V T ∪V N
○ P: insieme di produzioni, relazioni binarie
○ s ∈V N → assioma
● L(G): insieme delle stringhe di terminali ottenibili con finite operazioni di riscrittura
○ Applicazione delle regole di produzione, in vario modo
Linguaggio generato da G
● Derivazione diretta → Riscrittura di una stringa tramite applicazione di una regola da
produzione
● Derivazione → Chiusura riflessiva e transitiva della derivazione diretta
● Forma di frase → Stringa x t.c. x ∈ V∗, S ⇒∗x
● Linguaggio generato da G → forme di frase con soli simboli terminali
Classificazione di Chomsky
● Tipo 0 → Grammatiche ricorsivamente enumerabili
● Tipo 1 → grammatiche contestuali
● Tipo 2 → Grammatiche non contetuali
● Tipo 3 → Grammatiche regolari

Linguaggi non contestuali

● Controllo di palindromi, bilanciamento di parentesi e varie simmetrie
● Linguaggi di programmazione comuni: grammatiche CF
● Definizione con notazione Extended BAckus-Naur Form
Espressioni infisse e prefisse
● Notazione infissa, con precedenza tra operatori
● Notazione prefissa, o polacca
Qui ho balzato una parte perché non si capisce un cazzo di niente

Linguaggi di programmazione
Notazione formale per definire algoritmi(= sequenza di istruzioni per risolvere un dato
problema in un tempo finito). Linguaggio caratterizzato da: sintassi, semantica

Sintassi → Insieme di regole formali per scrivere frasi ben formate in un certo linguaggio → LEssico:
parole riservate, operatori, variabili, costanti
Grammatiche non contestuali espresse con notazioni formali:BNF, EBNF, Diagrammi
sintattici
Semantica → Attribuisce un significato alle frasi costruite nel linguaggio. Una frase può
essere sintatticamente corretta e tuttavia non avere significato
 ● Correttezza sui tipi
● Semantica operazionale

Linguaggi di basso livello

● Più orientati alla macchina che ai problemi da trattare
○ Linguaggi macchina → Solo operazioni eseguibili direttamente dall’elaboratore
○ Linguaggi assembly → Prima evoluzione, codici binari → mnemonici
Linguaggi di alto livello
● Introdotti per facilitare scrittura programmi
● Definizione della soluzione in modo intuitivo, con una certa astrazione
● Vanno tradotti in linguaggio macchina

Paradigmi di sviluppo
● Forniscono la filosofia e la metodologia
● Definiscono in concetto astratto di computazione
● Ogni linguaggio consente l’adozione di un particolare paradigma
○ Imperativo
○ Object-oriented
○ Scripting
○ Funzionale
○ Logico
Esecuzione dei programmi
● Linguaggio ad alto livello → passi necessari:
○ Compilazione
○ Collegamento con librerie di supporto
○ Caricamento in memoria
● Programmi compilati: applicati i 3 passi a tutto il codice
● Programmi interpretati: applicati i tre passi comando per comando a tempo di
esecuzione
Compilazione
● Traduzione da linguaggio alto lvl a linguaggio macchina
○ Analisi: lessicale, grammaticale, contestuale
○ Rappresentazione intermedia: albero sintattico annotato (AST)
○ Generazione codice oggwwtto
○ Codice oggetto non ancora eseguibile → Linker, loader
Collegamento
● Il linker collega diversi moduli oggetto
○ Simboli irrisolti → Riferimenti esterni
○ Il collegamento può essere statico o dinamico
■ Statico → Libreria inclusa nel file oggetto, eseguibile stand-alone.
Dimensioni maggiori ma possibilità di includere solo funzionalità
utilizzate
■ Dinamico → Librerie condivise da diverse applicazioni. Installazione
ed aggiornamento unici, caricate in memoria una sola volta
Caricamento
● Il loader carica in memoria un programma
○ Risolve indirizzi logici
○ Carica eventuali programmi di supporto
 ● Rilocazione statica → Indirizzi logici trasformati in indirizzi assoluti
● Rilocazione dinamica → Indirizzi logici mantenuti, relativi alla posizione del
programma in memoria
○ Registri base della CPU
○ Memory Management Unit
Codice Gestito
● Compilazione in codice intermedio:
○ Bytecode(Java)
○ Python → Compilato per una macchina virtuale ma in modo trasparente
● Esecuzione su macchina virtuale:
○ Java Virtual Machine
○ Emulazione di un certo elaboratore → Indipendenza dalla piattaforma
○ Compilazione Just In Time in codice nativo
○ Gestione memoria con Garbage Collector
Garbage Collection
● Restituzione automatica della memoria → Oggetti/dati che non servono più
● Possibile anche per codice nativo (es. Linguaggio Go)
● Diversi algoritmi → Reference counting, Mark&Sweep, Generational garbage collection
Uso:
● Vantaggi:
○ Si libera sistematicamente la memoria
○ Non si rimuovono dati ancora utile
○ Dati rilocati per compattare la memoria
● Svantaggi
○ Processore più occupato
○ Memoria più occupata
○ GC decide autonomamente quando operare (problema per real time)