¿Se interpretan siempre los lenguajes dinámicos?

Mirando la mayoría de los lenguajes dinámicos (si no todos) (por ejemplo, Python, PHP, Perl y Ruby), todos se interpretan. Corrígeme si me equivoco. ¿Hay algún ejemplo de lenguaje dinámico que pase por la fase de compilación? ¿Es el lenguaje dinámico idéntico al lenguaje interpretado?

Mirando la mayoría (si no todos) los lenguajes dinámicos [es decir, Python, PHP, Perl y Ruby], todos se interpretan.

No es verdad. Puede compilar la fuente de Python. Esa es una prueba existencial.

Hay intérpretes para lenguajes tipados estáticamente y compiladores para lenguajes tipados dinámicamente. Los dos conceptos son ortogonales.

Nota al margen: en general, un lenguaje es solo eso: un lenguaje, con un conjunto de construcciones sintácticas para expresar la semántica. Si escribe Python en una pizarra, ¡todavía se llama Python! Es la implementación que puede ser un intérprete o un compilador. Ser de tipo estático o de tipo dinámico (como una especie de híbrido de ambos) es una propiedad del lenguaje, mientras que la ejecución de un programa mediante interpretación o compilación es una propiedad de la implementación.

Common Lisp se escribe de forma dinámica (y fuerte) y generalmente se compila .

Dado que esta dinámica se logra en tiempo de ejecución, hay algunas directivas que puede usar en el código fuente para asegurar al compilador que un símbolo contendrá solo un cierto tipo de valor, de modo que el compilador pueda optimizar el código generado y aumentar el rendimiento.

C # 4.0 admite tipos dinámicos (enlace tardío) y se compila.

node.js se basa en el motor javascript V8 de Google. V8 hace compilación en tiempo de ejecución. V8 es cegadoramente rápido dado ese hecho. Simplemente consulte http://shootout.alioth.debian.org y compare V8 con cualquiera de los idiomas interpretados anteriormente.

No, ciertamente es posible compilar lenguajes dinámicos.

Incluso hay algunos lenguajes dinámicos que siempre se compilan por diseño (por ejemplo, Clojure).

Sin embargo, la pregunta toca un punto relacionado importante: aunque los lenguajes dinámicos se pueden compilar, a menudo se da el caso de que los idiomas dinámicos no se pueden compilar en un código que sea tan eficiente como un lenguaje tipado estáticamente . Esto se debe a que hay algunas características inherentes a los lenguajes dinámicos que requieren verificaciones de tiempo de ejecución que serían innecesarias en un lenguaje compilado estáticamente.

Un ejemplo de esto: los lenguajes que permiten el parcheo de objetos en tiempo de ejecución (por ejemplo, Ruby) a menudo requieren que el objeto sea inspeccionado (con una búsqueda de tabla hash o similar) cada vez que invocas un método en el objeto. Incluso si esto se compila, el compilador tendrá que generar código para realizar la búsqueda del método en tiempo de ejecución. Hasta cierto punto, esta búsqueda de métodos no es diferente de lo que un intérprete tendría que hacer.

Esto agrega una sobrecarga significativa en comparación con una llamada a un método en un lenguaje como Java, donde el compilador puede determinar estáticamente el método correcto a partir de la definición de clase y reducirlo a una simple llamada a función en código nativo.

Creo que es este efecto, más que cualquier otra cosa, lo que hace que los lenguajes dinámicos tengan un rendimiento más lento en promedio que sus homólogos compilados estáticamente. Como puede ver en los puntos de referencia defectuosos , son los lenguajes estáticamente escritos (C, Java, Fortran, etc.) los que tienden a ser más rápidos con los lenguajes dinámicos (Perl, Python, Ruby, PHP, etc.) en la parte inferior de la clasificación.

Érase una vez, BASIC fue interpretado. Y algunas variantes de BASIC tenían escritura dinámica. Y también puedes obtener compiladores para ellos.

(Esto fue en los días de las unidades de disquete de 100K, cuando los dinosaurios todavía vagaban por la tierra y comían desprevenidos desarrolladores s / w para el desayuno).

Las diferentes implementaciones de Smalltalk manejan esto de manera diferente, pero varias de ellas se compilan en bytecodes que se ejecutan en una VM de alto rendimiento.

De hecho, la mayoría de los llamados lenguajes "interpretados" pasan por / permiten una compilación justo a tiempo para que se ejecute más rápido. Y algunos de ellos deben compilarse en código de bytes antes de poder ejecutarlos.

De hecho, dinámico e interpretado son totalmente 2 ideas diferentes, aunque existe una correlación. La razón es que quien siente que la escritura dinámica hace que su trabajo sea más fácil y rápido, no les importaría que el código se ejecute un poco más lento pero portátil.

Chrome, IE9 y Firefox 3.1+ compilan JavaScript para binarios nativos, y JavaScript se escribe dinámicamente.

Creo que la razón por la que los lenguajes dinámicos históricamente tienden a ser interpretados es porque la escritura y la interpretación dinámicas (o más específicamente, la falta de compilación) tienden a ser características útiles para los lenguajes de scripting y las tareas de scripting en general.

El rendimiento tampoco es (no fue) una gran preocupación para los tipos de programas que se escribieron en estos idiomas, por lo que, una vez más, la sobrecarga de escritura e interpretación dinámicas no fue un problema tan grande como lo sería en los idiomas ese valor de rendimiento.

Python es, típicamente, compilado. Es cierto que se compila en un código de bytes que luego se interpreta.

Perl trabaja de manera similar.

Common Lisp, típicamente, compilará uno de código nativo o byte. Esto difiere entre implementaciones (y, hasta cierto punto, dentro de una implementación, dependiendo de varias configuraciones de optimización).

Si. Todos los lenguajes dinámicos son lenguaje interpretado (pero un lenguaje interpretado podría ser no dinámico).

La razón es simple: si es dinámico, necesita un intérprete para realizar el dinamismo a nivel de la compilación binaria.

ex. : cuando colocamos un dato en una variable PHP, luego otro de un tipo diferente, nuestro programa no pudo compilarse en código binario ya que cada tipo tiene su propio formato de representación binaria; el intérprete gestiona los cambios a nivel binario de forma dinámica