Il ciclo di vita di un programma
Un programma scritto in un linguaggio ad alto livello prende il nome di codice sorgente. Il microprocessore può eseguire esclusivamente codice macchina — sequenze binarie di istruzioni. Il codice sorgente deve quindi essere tradotto prima di poter essere eseguito.
Esistono tre modalità di traduzione, ognuna adatta a contesti diversi:
Linguaggi compilati — C / C++
Nei linguaggi compilati la traduzione avviene interamente prima dell’esecuzione. Il processo si articola in due fasi principali.
Fase 1 — Compilazione
.o — codice macchina parziale, non ancora eseguibile autonomamenteFase 2 — Linking
.o prodotti dalla compilazione.exe, a.out) — codice macchina completo e autonomo/* main.c — codice sorgente */
int main() {
return 0;
}
/* Processo di compilazione e linking */
gcc main.c → main.o (compilazione)
→ a.out (linking)Linguaggi interpretati — JavaScript
Nei linguaggi interpretati la traduzione avviene durante l’esecuzione. L’interprete legge il codice sorgente, lo traduce progressivamente ed esegue immediatamente ogni istruzione — senza produrre un file eseguibile autonomo.
// script.js — eseguito direttamente dall'interprete
console.log("Ciao Mondo!");
alert("Benvenuto!");.pyc). I motori JavaScript moderni usano compilazione JIT (Just-In-Time) che compila le parti critiche a runtime. La distinzione netta compilato/interpretato è quindi una semplificazione utile didatticamente, ma la realtà è più sfumata.Modello ibrido a bytecode — Java
Java introduce un approccio intermedio: il codice sorgente viene compilato in bytecode — un formato intermedio non legato a nessuna architettura hardware. Il bytecode viene poi eseguito dalla JVM (Java Virtual Machine), presente su ogni piattaforma.
// HelloWorld.java — sorgente
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
// Processo
javac HelloWorld.java → HelloWorld.class (bytecode)
java HelloWorld → esecuzione via JVM.java → .class (bytecode)Assemblatore e linguaggio Assembly
L’assemblaggio è il processo di traduzione specifico del linguaggio Assembly. A differenza dei linguaggi ad alto livello, qui la corrispondenza tra istruzione simbolica e codice macchina è quasi diretta — ogni istruzione Assembly corrisponde a una (o pochissime) istruzioni macchina.
MOV AX, BX) in codice macchina.o o .obj); programma.asm — sorgente Assembly
MOV AX, BX ; istruzione simbolica
; Processo
nasm programma.asm → programma.o (assemblaggio)
ld programma.o → programma.exe (linking)Sintesi comparativa
| Linguaggio | Compilazione | Assemblaggio | Linking | File prodotto |
|---|---|---|---|---|
| C / C++ | ✔ | ✖ | ✔ | .exe / a.out |
| Assembly | ✖ | ✔ | ✔ | .exe / a.out |
| Interpretato puro | ✖ | ✖ | solo dinamico | nessuno |
| Java (ibrido) | ✔ bytecode | ✖ | dinamico (JVM) | .class |
Collegamento al corso — microprocessore 8086
Nel contesto dello studio del microprocessore 8086 lavoreremo direttamente con il linguaggio Assembly. Questo significa che:
Riepilogo
- Il codice sorgente deve essere tradotto in codice macchina prima dell’esecuzione
- Nei linguaggi compilati (C/C++) la traduzione avviene prima dell’esecuzione — produce un eseguibile autonomo ad alte prestazioni
- Il compilatore genera file oggetto (
.o) — codice macchina parziale non ancora collegato - Il linker unisce i file oggetto e le librerie producendo il file eseguibile finale
- Nei linguaggi interpretati (JavaScript) la traduzione avviene a runtime — nessun eseguibile autonomo
- Il modello ibrido (Java) compila in bytecode eseguito dalla JVM — portabile su qualsiasi piattaforma
- L’assemblatore traduce Assembly in codice macchina con corrispondenza quasi 1:1
- Nel corso 8086 usiamo Assembly — il codice prodotto è codice macchina reale eseguito direttamente dalla CPU