Lingue gestite vs differenza di lingua compilata?

Mi confondo quando le persone cercano di distinguere tra lingue compilate e lingue gestite. Per esperienza, capisco che la maggior parte considera i linguaggi compilati come C, C ++ mentre i linguaggi gestiti sono Java, C # (ce ne sono ovviamente altri, ma questi sono solo alcuni esempi). Ma qual è esattamente la differenza fondamentale tra i due tipi di lingue?

La mia comprensione è che qualsiasi programma, indipendentemente dalla lingua utilizzata, viene essenzialmente "compilato" in un codice macchina di basso livello che viene quindi interpretato, quindi un po 'rende le lingue gestite un sottoinsieme di lingue compilate (ovvero, tutte le lingue gestite sono lingue compilate ma non viceversa)?

La differenza non sta nel "compilato" rispetto al "gestito", questi sono due assi ortogonali. Per "gestito" significano normalmente una presenza di una gestione della memoria raccolta dati inutili e / o una presenza di un'infrastruttura di macchina virtuale. Entrambi non hanno assolutamente nulla a che fare con la compilazione e qualunque cosa la gente ritenga opposta.

Tutte queste "differenze" sono piuttosto sfocate, artificiali e irrilevanti, poiché è sempre possibile mescolare la memoria gestita e non gestita in un singolo runtime, e anche una differenza tra compilazione e interpretazione è molto vaga.

Per citare Wikipedia:

Managed code è un termine coniato da Microsoft per identificare il codice sorgente del programma per computer che richiede e verrà eseguito solo sotto la gestione di una macchina virtuale Common Language Runtime (risultante in bytecode).

Il codice gestito richiede un runtime (come .NET CLT) per essere eseguito.

Penso che ci sia una distinzione da fare, tuttavia non è necessariamente tra "Compilato" e "Gestito". Questi non sono opposti; una lingua può essere compilata e non gestita, interpretata (non compilata) e gestita, o entrambi, o addirittura nessuno dei due.

Un linguaggio "compilato" è semplicemente un linguaggio in cui esiste un passaggio che trasforma il codice sorgente scritto dallo sviluppatore in un "bytecode" più regolare che è ciò che viene eseguito dalla macchina. La "macchina" può essere il processore effettivo o una "macchina virtuale" che esegue operazioni aggiuntive sui bytecode per tradurle in istruzioni "native" della macchina. L'antonimo di un linguaggio "compilato" è un linguaggio "interpretato", in cui il codice sorgente viene trasformato in istruzioni bytecode in fase di esecuzione, riga per riga man mano che vengono eseguite, senza una fase di compilazione. Un ibrido tra loro è "jitting", da "JIT" (Just In Time), che di solito è interpretato come un passaggio una tantum dalla macchina esecutiva;

Una lingua "gestita" è una lingua progettata per produrre programmi che vengono consumati all'interno di un ambiente di runtime specifico, che include quasi sempre un interprete bytecode; una "macchina virtuale" che accetta il codice del programma ed esegue una trasformazione aggiuntiva specifica per macchina o ambiente. L'ambiente può anche includere la gestione della memoria, come un "garbage collector" e altre funzionalità di "sicurezza" intese a mantenere il programma operativo all'interno della sua "sandbox" di spazio e strumenti, tuttavia tali funzionalità non sono il solo dominio dei runtime "gestiti" . Praticamente tutti i linguaggi interpretati possono essere considerati gestiti, poiché richiedono che l'interprete sia in esecuzione sotto le righe del codice "utente" in esecuzione. Inoltre, i linguaggi JVM e .NET (Java, Scala, C #, VB, F #, IronWhatever) sono compilati in un linguaggio intermedio o IL, che è superficialmente simile per forma e funzione a un linguaggio di assemblaggio binario, ma non aderisce al 100% a nessun set di istruzioni "native". Queste istruzioni sono eseguite da JVM o dal CLR di .NET, che le traduce efficacemente in istruzioni binarie native specifiche dell'architettura della CPU e / o del sistema operativo della macchina.

Pertanto, le lingue possono generalmente essere descritte come "compilate" o "interpretate" e come "non gestite" (o "native") e "gestite". Esistono linguaggi che possono essere descritti come una qualsiasi combinazione di questi ad eccezione del possibile "interpretato nativo" (che sarebbe vero solo per i codici operativi esadecimali scritti a mano, dove ciò che è scritto dallo sviluppatore è ciò che viene eseguito); se si considera il livello di interpretazione come un "runtime" (di cui è facile discutere e per cui è difficile discutere), tutti i linguaggi interpretati vengono "gestiti".

Se vuoi essere tecnico, quasi tutti i programmi destinati a un sistema operativo multitasking al giorno d'oggi sono "gestiti"; il sistema operativo creerà una "macchina virtuale" per ogni programma in esecuzione, in cui il programma pensa (o almeno non deve sapere diversamente) che è l'unica cosa in esecuzione. Il codice può effettuare chiamate all'interno di se stesso e verso altre librerie di riferimento come se quel programma fosse l'unica cosa caricata in memoria; allo stesso modo, le chiamate per allocare RAM e altra memoria superiore per archiviare e manipolare dati e dispositivi di controllo sono codificate come se l'intera architettura di memoria fosse disponibile. La VM (e il sistema operativo dietro di essa) quindi traduce vari puntatori di memoria nella posizione effettiva del programma, i suoi dati e si aggancia ai driver di dispositivo, ecc. Ciò avviene spesso applicando un offset di memoria (ogni VM riceve un blocco di 2 GB o qualunque sia la memoria, a partire dall'indirizzo X che il programma può trattare come se X fosse l'indirizzo 0) e come tale è molto economico da fare, ma ci sono altre cose di cui è responsabile il kernel del sistema operativo, come la pianificazione dei processi e la comunicazione tra processi, che sono più complicato da gestire. Tuttavia, questo modello di base non viene generalmente considerato "gestito", poiché il programma non deve sapere che è gestito da una macchina virtuale ed è spesso responsabile di mantenere "pulita" la memoria allocata. Un programma progettato per essere eseguito sulla riga di comando di MS-DOS può essere eseguito su sistemi operativi Windows più recenti che non hanno nemmeno l'ambiente MS-DOS al di sotto di essi; al programma viene invece assegnato un ambiente "console virtuale" e purché non tenti di lasciare questa "sandbox"

Managed Language in termini semplici è un linguaggio di alto livello che dipende da servizi forniti da un ambiente di runtime da eseguire, come il servizio di garbage collection, ecco perché viene chiamato gestito in generale ma non è l'unico servizio che utilizza e alcuni di questi servizi sono security services, exception handling, standard typesusati Common Language Run-time CLRper essere eseguiti, come nei linguaggi .Net o in un ambiente virtuale come Java che utilizza Java Virtual Machine JVM.

Unmanaged Language è un linguaggio di basso livello eseguibile direttamente dal sistema operativo senza la necessità di servizi di runtime virtuali o lingua intermedia, tali lingue come C, C++codice non gestito prodotto da tali lingue utilizzano routine di libreria che sono dinamicamente collegate al sistema operativo per ottenere il codice per eseguire chiamate DLL (Dynamic Link Libraries), il codice non gestito accede direttamente alla memoria ed è per questo che è più veloce del codice gestito, ma a meno che tu non stia costruendo un driver hardware o un videogioco sofisticato non vuoi davvero usare linguaggi non gestiti come può essere pericoloso lavorare in particolare con sviluppatori inesperti come lo stato del ruolowith great power comes great responsibilityed è per questo che esistono linguaggi gestiti per aiutare gli sviluppatori a produrre codice estensibile senza immergersi nella parte inferiore del sistema, ma è comunque possibile creare codice misto se necessario, questi articoli spiegano tutto:

Una panoramica dell'interoperabilità del codice gestito / non gestito

Esempio: miscelazione di codice C ++, C ++ / CLI e C # non gestito