Intèrpret (informàtica)

De Viquipèdia
Dreceres ràpides: navegació, cerca

A ciències de la computació, intèrpret o interpretador és un programa informàtic capaç d'analitzar i executar altres programes, escrits en un llenguatge d'alt nivell. Els intèrprets es diferencien dels compilador és que mentre aquests tradueixen un programa des de la seva descripció en un llenguatge de programació al codi de màquina del sistema, els primers (els intèrprets) només fan la traducció a mesura que sigui necessària, típicament, instrucció per instrucció, i normalment no guarden el resultat d'aquesta traducció.

Usant un intèrpret, un sol fitxer font pot produir resultats iguals fins i tot en sistemes summament diferents (ex. una PC i un PlayStation 3). Usant un compilador, un sol fitxer font pot produir resultats iguals només si és compilat a diferents executables específics a cada sistema.

Els programes interpretats solen ser més lents que els compilats a causa de la necessitat de traduir el programa mentre s'executa, però a canvi són més flexibles com entorns de Programació d'ordinadors i depuració (el que es tradueix, per exemple, en una major facilitat per a reemplaçar parts senceres del programa o afegir mòduls completament nous), i permeten oferir al programa interpretat un entorn no dependent de la màquina on s'executa l'intèrpret, sinó del propi intèrpret (el que es coneix comunament com màquina virtual).

Per millorar l'acompliment, algunes implementacions de programació de llenguatges de programació poden interpretar, o compilar el codi font original en una més compacta forma intermèdia i després traduir això al codi de màquina (ex. Perl, Python, MATLAB, i Ruby). Alguns accepten els fitxers font guardats en aquesta representació intermèdia (ex. Python, UCSD Pascal i Java).

Comparant la seva actuació amb la d'un ésser humà, un compilador equival a un traductor professional que, a partir d'un text, prepara un altre independent traduït a una altra llengua, mentre que un intèrpret correspon a l'intèrpret humà, que tradueix de viva veu les paraules que sent, sense deixar constància per escrit.

En l'actualitat, un dels entorns més comuns d'ús dels intèrprets informàtics és Internet, a causa de la possibilitat que aquests tenen d'executar independentment de la plataforma.

Interpretadors de bytecode[modifica | modifica el codi]

Article principal: bytecode

Hi ha un espectre de possibilitats entre la interpretació i la compilació, depenent de la quantitat d'anàlisi realitzats abans que el programa sigui executat. Per exemple, el Emacs Lisp és compilat a bytecode, que és una representació altament comprimida i optimitzada de l'codi font del Lisp, però no és codi de màquina (i per tant no està lligat a qualsevol maquinari particular). Aquest codi "compilat" és llavors interpretat per un interpretador de bytecode (que està escrit en C). En aquest cas, el codi compilat és el codi de màquina per a una màquina virtual, que no està implementada en el maquinari, sinó en l'interpretador de bytecode. El mateix acostament és utilitzat amb el codi Forth utilitzat en sistemes Open Firmware: el llenguatge font és compilat en "codi F" (un bytecode), que llavors és interpretat per una màquina virtual.

Eficiència[modifica | modifica el codi]

El principal inconvenient dels interpretadors és que quan s'interpreta un programa, típicament corre més lentament que si hagués estat compilat. La diferència en velocitats pot ser minúscula o gran; sovint un ordre de magnitud i de vegades més. Generalment pren més temps córrer un programa sota un interpretador de córrer el codi compilat, però pot prendre menys temps per interpretar que el temps total requerit per compilar i executar-lo. Això és especialment important si s'està fent i provant un codi prototip quan un cicle d'editar, interpretar i depurar l'interpretador, sovint pot ser molt més curt que el cicle d'editar, compilar, executar i depurar del compilador.

La interpretació de codi és més lenta que l'execució de codi compilat perquè l'interpretador ha d'analitzar cada sentència en el programa cada vegada que és executada i llavors realitzar l'acció desitjada, mentre que el codi compilat només realitza l'acció dins d'un determinat context fix per la compilació. Aquesta anàlisi en temps d'execució es coneix com "sobrecàrrega interpretativa". En un interpretador, l'accés a les variables és també més lent perquè el mapeig d'identificadors cap a les localitzacions d'emmagatzematge s'ha de fer repetidament en temps d'execució en lloc del temps de compilació. Hi ha diversos compromisos entre la velocitat de desenvolupament al utilitzar un interpretador i la velocitat d'execució en usar un compilador. Alguns sistemes (per exemple, alguns LISP s) permeten al codi interpretat i al compilat dir l'un a l'altre i compartir variables. Això significa que una vegada que una rutina ha estat provada i depurada sota l'interpretador pot ser compilada i per tant beneficiar-se d'una execució més ràpida mentre que altres rutines estan sent desenvolupades. Molts interpretadors no executen el codi font tal com està sinó que el converteixen en una forma interna més compacta. Per exemple, alguns interpretadors BASIC reemplacen paraules clau (keywords) amb símbols d'un simple byte que poden ser usats per trobar la instrucció en una taula de salts. Un interpretador pot bé fer servir el mateix analitzador lexicogràfic i el analitzador sintàctic (parser) que el compilador i llavors interpretar el arbre de sintaxi abstracta resultant.

Interpretadors d'arbre de sintaxi abstracta[modifica | modifica el codi]

En l'espectre entre la interpretació i la compilació, un altre apropament està transformant el codi font en un arbre de sintaxi abstracta optimitzat (AST), i després es procedirà a executar el programa seguint aquesta estructura arborescent.[1] En aquest acostament cada sentència necessita ser analitzada (parser) només una vegada. Com una avantatge sobre el bytecode, l'AST manté l'estructura i les relacions globals del programa entre les sentències (que es perden en una representació de bytecode), i proporciona una representació més compacta.[2]

Així, el AST s'ha proposat com un millor format intermedi per als compiladors just a temps que el bytecode. També, permet realitzar un millor anàlisi durant temps d'execució. Un interpretador Java Segons AST ha demostrat ser més ràpid que un interpretador similar basat en bytecode,[3] gràcies a les més poderoses optimitzacions permeses en tenir l'estructura completa del programa, així com tipus de dades d'alt nivell, disponibles durant l'execució.

Compilació just a temps[modifica | modifica el codi]

Per desdibuixar més la distinció entre els interpretadors, els interpretadors de bytecode i la compilació, hi ha la compilació just a temps (o JIT), una tècnica en la qual la representació intermèdia és compilada a codi de màquina nadiu en temps d'execució. Això confereix l'eficiència d'executar el codi nadiu, al cost de temps d'inici i d'un ús creixent de la memòria quan el bytecode o l'AST és compilat per primera vegada. L'optimització adaptativa és una tècnica complementària en la qual l'interpretador fa una anàlisi d'acompliment del programa que està corrent (profiling) i compila les seves parts més freqüentment executades a codi natiu. Ambdues tècniques tenen algunes dècades, apareixent en llenguatges com ara Smalltalk en els anys 1980.

En anys recents, la compilació just a temps ha guanyat l'atenció de la majoria dels implementadors de llenguatges de programació, amb Java, Python, i el Microsoft . NET Framework tots ara incloent JITs.

Interpretador de targeta perforada[modifica | modifica el codi]

El terme "interpretador" sovint es referia a una peça de equip de registre d'unitat que podia llegir targetes perforades i imprimir els caràcters a la targeta en una forma que podia ser llegida per humans. L'interpretador Numèric del IBM 550 i l'intèrpret Alfabètic del IBM 557 són exemples típics a partir de 1930 i 1954, respectivament.

Exemples[modifica | modifica el codi]

Alguns exemples de llenguatges que són normalment interpretats en comptes de compilats són:

Vegeu també[modifica | modifica el codi]

Referències[modifica | modifica el codi]

  1. AST intermediate Representations, Lambda the Ultimate fòrum
  2. .psu.edu/article/kistler97treebased.html A Tree-Based Alternative to Java Byte-Codes, Thomas Kistler, Michael Franz
  3. Trees Versus Bytes, BComp Honours thesis by Kade Hansson

Enllaços externs[modifica | modifica el codi]

  • IBM Card Interpreters page at Columbia University
  • DrPubaGump A tiny Interpreter written in Scheme, which provides to interpret PUBA-Gump (a subset of BASIC) in Scheme