línguas tipo dinâmico em comparação com linguagens tipo estático

Question

Quais são as vantagens e limitações de idiomas tipo dinâmico em comparação com linguagens tipo estático?

Veja também : que está com o amor de dinâmica línguas (um fio muito mais argumentativa ...)

Answer 1

A capacidade do intérprete para Tipo e digite conversões deduzir torna o tempo de desenvolvimento mais rápido, mas também pode provocar falhas de tempo de execução que você simplesmente não pode entrar em uma linguagem de tipagem estática onde você pegá-los em tempo de compilação. Mas qual deles é melhor (ou mesmo se isso é sempre verdade) é calorosamente discutido na comunidade nos dias de hoje (e desde há muito tempo).

Uma boa opinião sobre o assunto é de estática Typing Onde possível, tipagem dinâmica Quando necessário: o Fim da Guerra Fria entre Linguagens de Programação por Erik Meijer e Peter Drayton na Microsoft:

Os defensores da tipagem estática argumentam que as vantagens de tipagem estática incluem a detecção precoce de erros de programação (por exemplo impedindo a adição de um número inteiro para um booleano), melhor documentação na forma de Tipo de assinaturas (por exemplo, incorporando número e tipos de argumentos quando resolvendo nomes), mais oportunidades para optimizações do compilador (e.g. substituindo chamadas virtuais por direta chama, quando o tipo exato do receptor é conhecido estaticamente), aumento da eficiência de tempo de execução (por exemplo, não todos os valores precisa levar uma dinâmica tipo), e um melhor tempo de design experiência do desenvolvedor (por exemplo, conhecer o tipo de receptor, a IDE pode apresentar um menu drop-down de tudo membros aplicável). tipagem estática fanáticos tentam fazer-nos crer que “Os programas de bem-digitadas não pode dar errado”. Enquanto isso certamente soa impressionante, é uma vez vazia declaração. Estática verificação de tipo é um abstração em tempo de compilação do runtime comportamento do seu programa, e portanto, é necessariamente apenas parcialmente som e incompleta. Isso significa que programas ainda pode dar errado por causa de propriedades que não são rastreados pelo Tipo-verificador, e que existem programas que, enquanto eles não podem ir errado não pode ser verificada-tipo. o impulso para fazer tipagem estática menos Tipo de causas parciais e mais completas sistemas para tornar-se excessivamente complicado e exótica como testemunhado por conceitos tais como “tipos de fantasmas” [11] e “tipos bambas” [10]. Isto é como tentando correr uma maratona com uma bola e uma corrente amarrada a sua perna e triunfante gritando que quase tornou mesmo que você socorrida após a primeira milha.

Os defensores da tipagem dinâmica línguas argumentam que tipagem estática é demasiado rígida, e que a suavidade de linguagens dinamicamente os torna ideal para sistemas de prototipagem com a mudança ou desconhecidos requisitos, ou que interagem com outros sistemas que a mudança de forma imprevisível (dados e integração de aplicações). Claro, linguagens digitadas dinamicamente são indispensável para lidar com verdadeiramente comportamento dinâmico programa, tais como método de intercepção, de carga dinâmica, código móvel, reflexão tempo de execução, etc. Na mãe de todos os papéis em scripting [16], John Ousterhout argumenta que os sistemas de tipagem estática linguagens de programação tornar o código menos reutilizável, mais detalhado, não mais seguro, e menos expressiva do que dinamicamente linguagens de script digitado. este argumento é repetiu literalmente por muitos proponentes da tipagem dinâmica linguagens de script. Argumentamos que isso é uma falácia e cai na mesma categoria como argumentando que a essência da programação declarativa é eliminando atribuição. Ou, como John Hughes diz [8], é uma lógica impossibilidade de fazer uma linguagem mais poderoso omitindo características. Defendendo o fato de que atrasar tudo verificação de tipo de tempo de execução é um bom coisa, está jogando táticas de avestruz com o fato de que os erros devem ser capturados como no início do processo de desenvolvimento como possível.

Answer 2

sistemas de tipo estático procurar eliminar certos erros estaticamente, inspecionando o programa sem executá-lo e tentar provar solidez em certos aspectos. Alguns sistemas do tipo são capazes de capturar mais erros do que outros. Por exemplo, C # pode eliminar exceções de ponteiro nulo quando usado corretamente, enquanto que Java não tem tal poder. Twelf tem um sistema do tipo que na verdade href="http://www.cs.cmu.edu/~twelf/guide-1-2/twelf_7.html" que as provas terminará , "resolver" o parada problema .

No entanto, nenhum sistema de tipo é perfeito. A fim de eliminar uma determinada classe de erros, eles também devem rejeitar determinados programas perfeitamente válidas que violam as regras. É por isso que Twelf realmente não resolve o problema da parada, ele apenas evita-lo, jogando fora um grande número de provas perfeitamente válidas que acontecerá a terminar em formas estranhas. Da mesma forma, o sistema de tipo de Java rejeita implementação PersistentVector do Clojure devido ao seu uso de arrays heterogêneos. Ele funciona em tempo de execução, mas o sistema de tipo não pode verificá-lo.

Por essa razão, a maioria dos sistemas de tipo fornecem "escapes", maneiras de substituir o verificador estático. Para a maioria dos idiomas, estes tomam a forma de fundição, embora alguns (como C # e Haskell) têm modos inteiras que são marcados como "inseguro".

Subjetivamente, eu gosto de tipagem estática. Implementado corretamente (dica: não Java), um sistema de tipo estático pode ser uma grande ajuda na capina erros antes que eles travar o sistema de produção. linguagens dinamicamente digitados tendem a exigir mais testes de unidade, que é tedioso, o melhor dos tempos. Além disso, linguagens de tipagem estática pode ter certas características que são impossível ou inseguro em sistemas do tipo dinâmico ( conversões implícitas vêm à mente). É tudo uma questão de requisitos e gosto subjetivo. Eu não mais construir a próxima Eclipse em Ruby que eu iria tentar escrever um script de backup na Assembleia ou remendar um kernel usando Java.

Oh, e as pessoas que dizem que " x digitação é 10 vezes mais produtivo do que y digitar" são simplesmente soprando fumaça. tipagem dinâmica pode "sentir" mais rápido, em muitos casos, mas perde terreno uma vez que você realmente tentar fazer a sua inscrição fantasia executar . Da mesma forma, tipagem estática pode parecer que é a rede de segurança perfeito, mas um olhar para algumas das definições de tipo genérico mais complicado em Java envia a maioria dos desenvolvedores correndo para antolhos olho. Mesmo com sistemas de tipo e produtividade, não há bala de prata.

Nota final: não se preocupe com o desempenho quando se compara estático com tipagem dinâmica. EIC modernos como V8 e TraceMonkey estão chegando perigosamente-perto de desempenho de linguagem estática. Além disso, o fato de que Java realmente compila para baixo para uma linguagem intermediária inerentemente dinâmica deve ser um indício de que na maioria dos casos, tipagem dinâmica não é o grande desempenho-killer que algumas pessoas fazem para fora para ser.

Answer 3

Bem, ambos são muito, muito muito muito mal compreendido e também duas coisas completamente diferentes. que não são mutuamente exclusivas .

tipos estáticos são uma restrição da gramática da língua. langauges de tipagem estática estritamente poderia ser dito para não ser livre de contexto. A verdade simples é que se torna inconveniente para expressar uma linguagem sanely no contexto livre gramáticas que não tratar todos os seus dados simplesmente como vetores bits. sistemas de tipos estáticos são parte da gramática da língua se houver, eles simplesmente restringi-la mais do que um contexto livre gramática poderia, verificações gramaticais, assim, acontecer em duas passagens sobre a fonte de verdade. tipos estáticos correspondem à noção matemática de teoria dos tipos, a teoria tipo em matemática simplesmente restringe a legalidade de algumas expressões. Tipo, eu não posso dizer 3 + [4,7] em matemática, isso é por causa da teoria dos tipos do mesmo.

tipos estáticas não são, portanto, uma forma de 'evitar erros' de uma perspectiva teórica, eles são uma limitação da gramática. Na verdade, desde que +, 3 e intervalos tem o conjunto de definições teóricas habituais, se remover o sistema de tipo 3 + [4,7]has um resultado muito bem definido que é um conjunto. teoricamente não existem 'erros de tipo de tempo de execução', o uso prático do sistema de tipo é para evitar operações que para os seres humanos não faria sentido. Operações ainda são apenas o deslocamento e manipulação de pedaços de curso.

O problema disso é que um sistema do tipo não pode decidir se tais operações são vai ocorrer ou não se teria permissão para ser executado. Como, exatamente particionar o conjunto de todos os programas possíveis em aqueles que vão ter um 'erro de tipo', e aqueles que não são. Ele pode fazer apenas duas coisas:

1: provar que os erros do tipo vão ocorrer em um programa
2: provar que eles não vão ocorrer em um programa

Isto pode parecer que estou me contradizendo. Mas o que um verificador de tipo C ou Java faz é que rejeita um programa como 'ungrammatical', ou como ele chama de 'tipo de erro' se não pode ter sucesso em 2. Ele não pode provar que eles não vão ocorrer, isso não significa que eles não vão ocorrer, significa apenas que ele não pode provar isso. Pode muito bem ser que um programa que não terá um erro de tipo é rejeitado simplesmente porque ele não pode ser provada pelo compilador. Um exemplo simples ser if(1) a = 3; else a = "string";, com certeza, já que é sempre verdadeiro, a pessoa-branch nunca será executada no programa, e nenhum erro de tipo deverá ocorrer. Mas não pode provar esses casos de uma maneira geral, por isso é rejeitado. Esta é a principal fraqueza de uma série de linguagens de tipagem estática, em protegê-lo contra si mesmo, você está necessariamente também protegida em casos que você não precisa dele.

Mas, ao contrário do popular, acreditam, existem também linguagens de tipagem estática que o trabalho por princípio 1. Eles simplesmente rejeitar todos os programas dos quais eles podem provar isso vai causar um erro de tipo, e passar todos os programas de que não pode . Portanto, é possível que eles permitem que os programas que têm erros de tipo neles, um bom exemplo sendo digitado Racket, é híbrido entre dinâmico e tipagem estática. E alguns argumentam que você obtenha o melhor dos dois mundos neste sistema.

Outra vantagem de tipagem estática é que tipos são conhecidos em tempo de compilação, e, portanto, o compilador pode usar isso. Se em Java fazer "string" + "string" ou 3 + 3, tanto + fichas no texto, no final, representar uma operação e dado completamente diferente, o compilador sabe que para escolher os tipos sozinho.

Agora, eu vou fazer uma afirmação muito controversa aqui, mas paciência comigo: 'tipagem dinâmica' não existe

.

Sons muito controverso, mas é verdade, linguagens digitadas dinamicamente são de uma perspectiva teórica untyped . Eles estão apenas estaticamente línguas digitado com apenas um tipo. Ou simplesmente colocar, eles são linguagens que são de fato grammatically gerada por uma gramática livre de contexto na prática.

Por que eles não têm tipos? Porque cada operação é definida e permitiu a cada operante, o que é um 'tipo de tempo de execução de erro' exatamente? É a partir de um exemplo teórico puramente uma efeito colateral . Se fazendo print("string") que imprime uma string é uma operação, então é assim length(3), o primeiro tem o efeito colateral de escrever string para a saída padrão, o último simplesmente error: function 'length' expects array as argument., é isso. Não é a partir de uma perspectiva teórica existe tal coisa como uma linguagem de tipagem dinâmica. Eles são untyped

Tudo bem, a vantagem óbvia de linguagem 'tipagem dinâmica' é força de expressão, um sistema do tipo não é senão uma limitação do poder expressivo. E, em geral, as línguas com um sistema de tipo de fato teria um resultado definido para todas as operações que não são permitidos se o tipo de sistema foi simplesmente ignorada, os resultados simplesmente não faz sentido para os seres humanos. Muitas línguas perdem sua integralidade Turing após a aplicação de um sistema de tipo.

A desvantagem óbvia é o fato de que as operações podem ocorrer que produziria resultados que são sem sentido para os seres humanos. Para se proteger contra isso, linguagens digitadas dinamicamente normalmente redefinir essas operações, em vez de produzir esse resultado sem sentido que redefini-lo a ter o efeito colateral de escrever um erro, e, possivelmente, travar o programa completamente. Este não é um 'erro' em tudo, na verdade, a especificação da linguagem normalmente implica isso, este é tanto o comportamento da linguagem como imprimir uma seqüência de uma perspectiva teórica. sistemas do tipo forçar, assim, o programador para raciocinar sobre o fluxo do código para se certificar de que isso não aconteça. Ou, na verdade, a razão para que ele faz acontecer também pode ser útil em alguns pontos para a depuração, mostrando que não é um 'erro', mas uma propriedade bem definido da língua. Com efeito, o único remanescente de 'tipagem dinâmica' que a maioria das línguas têm se proteger contra uma divisão por zero. Isto é o que tipagem dinâmica é, não há tipos, não há mais tipos do que zero é um tipo diferente do que todos os outros números. O que as pessoas chamam de um 'tipo' é apenas uma outra propriedade de um dado, como o comprimento de uma matriz, ou o primeiro caractere de uma string. E muitas linguagens digitadas dinamicamente também permitem que você escreva coisas como "error: the first character of this string should be a 'z'".

Outra coisa é que as linguagens digitadas dinamicamente têm o tipo disponível em tempo de execução e, geralmente, pode verificá-lo e lidar com ele e decidir a partir dele. Claro que, em teoria, não é diferente do que acessar o primeiro caractere de uma matriz e de ver o que é. Na verdade, você pode fazer sua própria dinâmica C, basta usar apenas um tipo como long int longo e utilizar os primeiros 8 bits dele para guardar o seu 'tipo' em e funções de gravação de acordo com o cheque para ele e executar flutuador ou adição inteiro. Você tem uma linguagem de tipagem estática com um tipo, ou uma linguagem dinâmica.

Na prática, isso todos os shows, linguagens de tipagem estática são geralmente usado no contexto de escrever software comercial, enquanto línguas tipagem dinâmica tendem a ser usados ??no contexto de resolver alguns problemas e automatizar algumas tarefas. Escrevendo código em linguagens de tipagem estática simplesmente leva muito tempo e é complicado porque você não pode fazer as coisas que você sabe que está indo para vir ok, mas o sistema de tipo ainda protege contra si mesmo por erros que não fazem. Muitos programadores nem sequer percebem que eles fazem isso porque é em seu sistema, mas quando você o código em linguagens estáticas, muitas vezes você contornar o fato de que o sistema de tipo não vai deixar você fazer coisas que não podem dar errado, porque não pode provar que não vai dar errado.

Como eu disse, 'digitado estaticamente' em meios caso geral 2, culpado até que se prove o contrário. Mas algumas línguas, que não derivam seu sistema de tipo de teoria tipo em tudo regra utilização 1: inocente até provado guilty, que pode ser o híbrido ideal. Então, talvez digitado Racket é para você.

Além disso, assim, para um exemplo mais absurdo e extrema, estou actualmente a implementar uma linguagem onde 'tipos' são verdadeiramente o primeiro caractere de uma matriz, eles são dados, os dados do 'tipo', 'tipo', que é ele próprio um tipo e ponto de referência, o único dado que se tem como um tipo. Tipos não são finito ou limitado estaticamente, mas novos tipos podem ser gerados com base em informações de tempo de execução.

Answer 4

Talvez o único grande "benefício" de tipagem dinâmica é a curva de aprendizagem mais raso. Não existe um sistema tipo de aprender e nenhuma sintaxe não-trivial para casos de canto, tais como restrições de tipo. Isso faz tipagem dinâmica acessível a muito mais pessoas e viável para muitas pessoas para quem os sistemas sofisticados de tipo estático estão fora de alcance. Consequentemente, tipagem dinâmica pegou nos contextos de educação (por exemplo, Esquema / Python no MIT) e linguagens específicas de domínio para não-programadores (por exemplo, Mathematica ). linguagens dinâmicas também se agarraram em nichos onde eles têm pouca ou nenhuma concorrência (por exemplo, Javascript).

A mais concisa línguas dinamicamente digitado (por exemplo, Perl, APL, J, K, Mathematica ) são específicos do domínio e pode ser significativamente mais conciso do que o mais concisa de uso geral linguagens estaticamente tipadas (por exemplo, OCaml ) nos nichos que foram projetados para.

As principais desvantagens de tipagem dinâmica são:

• tipo erros em tempo de execução.

• Pode ser muito difícil ou mesmo praticamente impossível de alcançar o mesmo nível de correção e requer muito mais testes.

• Nenhuma documentação verificada pelo compilador.

• O mau desempenho (geralmente em tempo de execução, mas às vezes em tempo de compilação em vez disso, por exemplo Esquema Stalin) e desempenho imprevisível devido à dependência de otimizações sofisticadas.

Pessoalmente, eu cresci em linguagens dinâmicas, mas não tocá-los com um pólo de 40' como um profissional a menos que não havia outras opções viáveis.

Answer 5

De Typing do Artima: forte contra fraco, Static vs. dinâmica artigo:

fortes impede tipagem operações de mistura entre tipos incompatíveis. Para misturar tipos, você deve usar uma conversão explícita

meios fracos de digitação que você pode misturar tipos sem uma conversão explícita

No papel de Pascal Costanza, dinâmico vs. estática Typing - A Pattern-Based análise (PDF), ele afirma que, em alguns casos, tipagem estática é mais propenso a erros de digitação dinâmica. Algumas linguagens de tipagem estática forçá-lo a tipagem dinâmica emular manualmente, a fim de fazer "a coisa certa". É discutido em Lambda the Ultimate .

Answer 6

Depende do contexto. Lá muitos benefícios que são apropriados para sistema dinâmico digitado, bem como para forte digitado. Eu sou da opinião de que o fluxo de linguagem tipos dinâmicos é mais rápido. As linguagens dinâmicas não são constrangidos com atributos de classe e pensamento compilador do que está acontecendo no código. Você tem alguma liberdade meio. Além disso, a linguagem dinâmica normalmente é mais expressiva e resultam em menos código que é bom. Apesar disso, é mais propenso a erros que também é questionável e depende mais da cobertura de teste de unidade. É fácil protótipo com dinâmica lang mas a manutenção pode se tornar pesadelo.

O principal ganho sobre sistema estático digitado é o suporte IDE e analisador certamente estática de código. Você se torna mais confiante de código após cada mudança de código. A manutenção é a paz de bolo com tais ferramentas.

Answer 7

Há muitas coisas diferentes sobre linguagens estáticas e dinâmicas. Para mim, a principal diferença é que em linguagens dinâmicas as variáveis ??não têm tipos fixos; em vez disso, os tipos estão vinculados a valores. Devido a isso, o código exato que é executado é indeterminado até a execução.

Em implementações iniciais ou ingênuos este é um grande arrastar desempenho, mas EIC modernos obter tentadoramente perto do melhor que pode obter com a otimização compiladores estáticos. (Em alguns casos marginais, ainda melhor do que isso).

Answer 8

É tudo sobre a ferramenta certa para o trabalho. Nem é melhor 100% do tempo. Ambos os sistemas foram criados pelo homem e têm falhas. Desculpe, mas nós chupar e fazer coisas perfeito.

Eu gosto de tipagem dinâmica, porque ele fica fora do meu caminho, mas sim de tempo de execução erros podem rastejar até que eu não fiz plano para. Onde como tipagem estática pode corrigir os erros acima mencionados, mas dirigir um novato (em linguagens digitadas) programador louco tentando elenco entre um char constante e uma string.

Answer 9

estático Typing: As linguagens como Java e Scala são digitados estático.

As variáveis ??têm de ser definidas e inicializadas antes de serem usados ??em um código.

para ex. int x; x = 10;

System.out.println (x);

Tipagem Dinâmica: Perl é uma linguagem dinâmica digitado.

As variáveis ??não precisam ser inicializados antes de serem usados ??no código.

y = 10; usar essa variável na parte posterior do código