As linguagens dinâmicas são sempre interpretadas?

Observando a maioria das linguagens dinâmicas (se não todas) (por exemplo, Python, PHP, Perl e Ruby), todas elas são interpretadas. Corrija-me se eu estiver errado. Existe algum exemplo de linguagem dinâmica que passa pela fase de compilação? A linguagem dinâmica é idêntica à linguagem interpretada?

Analisando a maioria das linguagens dinâmicas (se não todas) [ie Python, PHP, Perl e Ruby], elas são todas interpretadas.

Não é verdade. Você pode compilar a fonte Python. Essa é uma prova existencial.

Existem intérpretes para idiomas de tipo estaticamente e compiladores para idiomas de tipo dinâmico. Os dois conceitos são ortogonais.

Nota lateral: em geral, uma linguagem é apenas isso: uma linguagem, com um conjunto de construções sintáticas para expressar semântica. Se você escrever Python em um quadro branco, ainda será chamado Python! É a implementação que pode ser um intérprete ou um compilador. Ser digitado estaticamente ou dinamicamente (do tipo híbrido de ambos) é uma propriedade da linguagem, enquanto a execução de um programa pela interpretação ou compilação é uma propriedade da implementação.

Lisp comum é digitado dinamicamente (e fortemente) e geralmente compilado .

Como essa dinâmica é alcançada no tempo de execução, existem algumas diretivas que você pode usar no código-fonte para garantir ao compilador que um símbolo mantenha apenas um certo tipo de valor, para que o compilador possa otimizar o código gerado e aumentar o desempenho.

O C # 4.0 oferece suporte a tipos dinâmicos (ligação tardia) e é compilado.

O node.js é baseado no mecanismo javascript V8 do Google. V8 faz compilação em tempo de execução. V8 é incrivelmente rápido, dado esse fato. Basta verificar http://shootout.alioth.debian.org e comparar V8 vs. qualquer um dos idiomas interpretados acima.

Não - certamente é possível compilar linguagens dinâmicas.

Existem até algumas linguagens dinâmicas que são sempre compiladas pelo design (por exemplo, Clojure).

No entanto, a pergunta aborda um ponto relacionado importante: embora as linguagens dinâmicas possam ser compiladas, geralmente é possível que linguagens dinâmicas não possam ser compiladas em códigos que sejam tão eficientes quanto uma linguagem de tipo estaticamente . Isso ocorre porque existem alguns recursos inerentes às linguagens dinâmicas que requerem verificações em tempo de execução que seriam desnecessárias em um idioma compilado estaticamente.

Um exemplo disso: linguagens que permitem a correção de objetos em tempo de execução (por exemplo, Ruby) geralmente exigem que o objeto seja inspecionado (com uma pesquisa de hashtable ou semelhante) sempre que você invocar um método no objeto. Mesmo que isso seja compilado, o compilador precisará gerar código para fazer a pesquisa do método em tempo de execução. Até certo ponto, essa pesquisa de método não é diferente do que um intérprete teria que fazer.

Isso adiciona uma sobrecarga significativa quando comparado a uma chamada de método em uma linguagem como Java, onde o método correto pode ser determinado estaticamente pelo compilador a partir da definição de classe e reduzido a uma simples chamada de função no código nativo.

Acredito que é esse efeito, mais do que qualquer outra coisa, que resulta em linguagens dinâmicas com desempenho mais lento, em média, do que suas contrapartes estaticamente compiladas. Como você pode ver nos benchmarks falhos , são as linguagens estaticamente tipadas (C, Java, Fortran etc.) que tendem a ser mais rápidas com as linguagens dinâmicas (Perl, Python, Ruby, PHP etc.) na parte inferior do ranking.

Era uma vez, BASIC foi interpretado. E algumas variantes do BASIC tinham digitação dinâmica. E você também pode obter compiladores para eles.

(Isso acontecia nos dias de 100 mil unidades de disquete, quando os dinossauros ainda vagavam pela Terra e comiam desenvolvedores s / w desavisados ​​no café da manhã.)

Diferentes implementações do Smalltalk lidam com isso de maneira diferente, mas várias delas são compiladas em bytecodes que são executados em uma VM de alto desempenho.

De fato, a maioria das linguagens "interpretadas" passam / permitem uma compilação just-in-time para torná-la mais rápida. E alguns deles precisam ser compilados para código de bytes antes que você possa executá-los.

De fato, dinâmico e interpretado são totalmente duas idéias diferentes, embora exista uma correlação. O motivo é que quem sente a digitação dinâmica torna seu trabalho mais fácil e rápido, eles não se importariam com o código ser um pouco mais lento, mas portátil.

Chrome, IE9 e Firefox 3.1+ compilam JavaScript em binários nativos, e o JavaScript é digitado dinamicamente.

Penso que a razão pela qual as linguagens dinâmicas historicamente tendem a ser interpretadas é porque a digitação e interpretação dinâmica (ou mais especificamente, a falta de compilação) tendem a ser recursos úteis para linguagens de script e tarefas de script em geral.

O desempenho também não é (não era) uma grande preocupação com os tipos de programas que foram escritos nessas linguagens; portanto, a sobrecarga da digitação e interpretação dinâmicas não era um problema tão grande quanto seria em linguagens. esse valor desempenho.

Python é, tipicamente, compilado. É certo que compilado para código de bytes que é interpretado.

Perl trabalha de maneira semelhante.

Normalmente, o Lisp comum será compilado em um código nativo ou de byte. Isso difere entre implementações (e, até certo ponto, dentro de uma implementação, dependendo de várias configurações de otimização).

Sim. Todas as linguagens dinâmicas são linguagem interpretada (mas uma linguagem interpretada pode não ser dinâmica).

O motivo é simples: se é dinâmico, ele precisa de um intérprete para executar o dinamismo no nível da compilação binária.

ex. : quando colocamos dados em uma variável PHP, depois mais tarde em outro tipo, nosso programa não pôde compilar em código binário, pois cada tipo tem seu próprio formato de representação binária; o intérprete gerencia os turnos no nível binário de maneira dinâmica