Bem, ambos são muito, muito, muito, muito mal compreendidos e também duas coisas completamente diferentes. que não são mutuamente exclusivos .
Tipos estáticos são uma restrição da gramática do idioma. Pode-se dizer que os idiomas digitados estaticamente não são estritamente livres de contexto. A verdade simples é que torna-se inconveniente expressar uma linguagem de maneira sadia nas gramáticas livres de contexto que não tratam todos os seus dados simplesmente como vetores de bits. Os sistemas de tipo estático fazem parte da gramática da linguagem, se houver, eles simplesmente a restringem mais do que uma gramática livre de contexto poderia, assim, as verificações gramaticais ocorrem em duas passagens sobre a fonte. Os tipos estáticos correspondem à noção matemática da teoria dos tipos; a teoria dos tipos na 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 do tipo.
Os tipos estáticos não são, portanto, uma maneira de "evitar erros" de uma perspectiva teórica, são uma limitação da gramática. De fato, desde que +, 3 e intervalos tenham as definições teóricas de conjunto usuais, se removermos o sistema de tipos, o 3 + [4,7]resultado será um conjunto bem definido. 'erros de tipo de tempo de execução' teoricamente não existem, o uso prático do sistema de tipos é impedir operações que, para seres humanos , não fazem sentido. Operações ainda são apenas a mudança e manipulação de bits, é claro.
O problema é que um sistema de tipos não pode decidir se essas operações ocorrerão ou não, se seria permitido executar. Por exemplo, particione exatamente o conjunto de todos os programas possíveis naqueles que terão um 'erro de tipo' e naqueles que não o são. Ele pode fazer apenas duas coisas:
1: provar que erros de tipo ocorrerão em um programa
2: provar que não ocorrerão em um programa
Pode parecer que eu estou me contradizendo. Mas o que um verificador de tipos C ou Java faz é rejeitar um programa como 'não-gramatical' ou como 'erro de tipo' se não tiver êxito em 2. Não pode provar que eles não ocorrerão, isso não significa que eles não vão ocorrer, apenas significa que não pode provar isso. Pode muito bem ser que um programa que não terá um erro de tipo seja rejeitado simplesmente porque não pode ser provado pelo compilador. Um exemplo simples sendoif(1) a = 3; else a = "string";, certamente, como sempre é verdade, o ramo else nunca será executado no programa e nenhum erro de tipo deverá ocorrer. Mas não pode provar esses casos de maneira geral, por isso é rejeitado. Essa é a principal fraqueza de muitas linguagens estaticamente tipificadas. Ao proteger você contra si mesmo, você também está necessariamente protegido nos casos em que não precisa.
Mas, ao contrário do que se pensa popular, também existem linguagens de tipo estatístico que funcionam pelo princípio 1. Eles simplesmente rejeitam todos os programas dos quais podem provar que causará um erro de tipo e passam todos os programas dos quais não podem. Portanto, é possível que eles permitam programas com erros de tipo, um bom exemplo sendo o Typed Racket, é híbrido entre a digitação dinâmica e a estática. E alguns argumentam que você obtém o melhor dos dois mundos neste sistema.
Outra vantagem da tipagem estática é que os tipos são conhecidos em tempo de compilação e, portanto, o compilador pode usar isso. Se em Java representamos "string" + "string"ou 3 + 3, ambos os +tokens no texto no final representam uma operação e dado completamente diferentes, o compilador sabe qual escolher apenas os tipos.
Agora, vou fazer uma declaração muito controversa aqui, mas tenha paciência comigo: 'datilografia dinâmica' não existe .
Parece muito controverso, mas é verdade, as linguagens dinamicamente tipadas são de uma perspectiva teórica não tipificadas . Eles são apenas idiomas de tipo estaticamente, com apenas um tipo. Ou, simplesmente, são linguagens que são de fato gramaticalmente geradas por uma gramática livre de contexto na prática.
Por que eles não têm tipos? Como todas as operações são definidas e permitidas em todos os operadores, o que é exatamente um 'erro de tipo de tempo de execução'? É de um exemplo teórico puramente um efeito colateral . Se fazer o print("string")que imprime uma string é uma operação, o mesmo ocorre com length(3)o primeiro efeito gravado stringna saída padrão, o último simplesmente error: function 'length' expects array as argument., é isso. De uma perspectiva teórica, não existe uma linguagem tipicamente dinâmica. Eles não são tipados
Tudo bem, a vantagem óbvia da linguagem "tipada dinamicamente" é o poder expressivo, um sistema de tipos nada mais é do que uma limitação do poder expressivo. E, em geral, linguagens com um sistema de tipos realmente teriam um resultado definido para todas as operações que não são permitidas se o sistema de tipos fosse apenas ignorado; os resultados simplesmente não teriam sentido para os seres humanos. Muitos idiomas perdem sua integridade de Turing após aplicar um sistema de tipos.
A desvantagem óbvia é o fato de que podem ocorrer operações que produziriam resultados sem sentido para os seres humanos. Para se proteger contra isso, as linguagens dinamicamente tipicamente redefinem essas operações, em vez de produzir esse resultado sem sentido, elas o redefinem para ter o efeito colateral de escrever um erro e possivelmente interromper o programa por completo. Isso não é um "erro", na verdade, a especificação da linguagem geralmente implica isso; esse é o comportamento da linguagem, tanto quanto imprimir uma string de uma perspectiva teórica. Assim, os sistemas de tipos forçam o programador a raciocinar sobre o fluxo do código para garantir que isso não aconteça. Ou, na verdade, a razão para que ele fazO acontecer também pode ser útil em alguns pontos da depuração, mostrando que não é um 'erro', mas uma propriedade bem definida do idioma. De fato, o único remanescente de 'digitação dinâmica' que a maioria dos idiomas possui está protegendo contra uma divisão por zero. É isso que é a digitação dinâmica, não há tipos, não há mais tipos do que zero é um tipo diferente de todos os outros números. O que as pessoas chamam de 'tipo' é apenas outra propriedade de um dado, como o comprimento de uma matriz ou o primeiro caractere de uma sequência. E muitas linguagens de tipo dinâmico também permitem que você escreva coisas assim "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 podem verificá-lo, lidar com ele e decidir a partir dele. Obviamente, em teoria, não é diferente de acessar o primeiro caractere de uma matriz e ver o que é. De fato, você pode criar seu próprio C dinâmico, apenas use apenas um tipo, como long long int, e use os primeiros 8 bits para armazenar seu 'tipo' e escrever funções de acordo, que o verificam e executam adição de número flutuante ou inteiro. Você tem um idioma digitado estaticamente com um tipo ou um idioma dinâmico.
Na prática, tudo isso mostra que linguagens estaticamente tipificadas são geralmente usadas no contexto de criação de software comercial, enquanto linguagens tipicamente dinâmicas tendem a ser usadas no contexto de solução de alguns problemas e automação de algumas tarefas. Escrever código em linguagens estáticas simplesmente leva muito tempo e é complicado porque você não pode fazer as coisas que sabe que vão dar certo, mas o sistema de tipos ainda protege você contra erros que você não comete. Muitos codificadores nem percebem que fazem isso porque está em seu sistema, mas quando você codifica em linguagens estáticas, geralmente trabalha com o fato de que o sistema de tipos não permite que você faça coisas que não podem dar errado, porque Não posso provar que não vai dar errado.
Como observei, "tipicamente estaticamente" em geral significa o caso 2, culpado até que se prove inocente. Mas algumas linguagens, que não derivam seu sistema de tipos da teoria de tipos, usam a regra 1: inocente até que se prove o contrário, que pode ser o híbrido ideal. Então, talvez o Typed Racket seja para você.
Além disso, para um exemplo mais absurdo e extremo, atualmente estou implementando uma linguagem em que 'tipos' são realmente o primeiro caractere de uma matriz, são dados, dados do 'tipo', 'tipo', que é ele próprio um tipo e dado, o único dado que tem a si próprio como um tipo. Os tipos não são finitos ou delimitados estaticamente, mas novos tipos podem ser gerados com base nas informações de tempo de execução.