Qual é o suposto ganho de produtividade da digitação dinâmica? [fechadas]

82

Ouvi muitas vezes a afirmação de que as linguagens dinamicamente tipadas são mais produtivas que as linguagens estaticamente. Quais são as razões para esta reivindicação? Não é apenas trabalhar com conceitos modernos, como convenção sobre configuração, uso de programação funcional, modelos avançados de programação e uso de abstrações consistentes? É certo que há menos confusão porque as declarações de tipo (por exemplo, em Java) geralmente redundantes não são necessárias, mas você também pode omitir a maioria das declarações de tipo em linguagens estaticamente tipadas que usam inferência de tipo, sem perder as outras vantagens da digitação estática. E tudo isso está disponível para linguagens modernas de tipo estatístico, como o Scala.

Então: o que há para dizer com relação à produtividade com a digitação dinâmica, que realmente é uma vantagem do próprio modelo de texto?

Esclarecimento: Estou mais interessado em projetos de grande / médio porte do que em hacks rápidos. :-)

Hans-Peter Störr
fonte
10
Você esperaria que a "dupla estática" seja mais rápida ou produtiva que a "dupla dinâmica"?
Steve314
O que você quer dizer com dupla? Enfim: posso pensar em algumas razões pelas quais a digitação estática é mais produtiva que a digitação dinâmica: mais compilador verifica erros, conclusão do código, mais informações sobre a intenção do programador no código. É por isso que estou perguntando sobre o inverso.
Hans-Peter Störr
11
Foi uma piada com razão. A "dupla dinâmica" é Batman e Robin. Eles não teriam tanto medo no submundo do crime de Gotham City se fossem chamados de "dupla estática". Como os desenvolvedores são pessoas, coisas superficiais podem fazer a diferença, independentemente do significado dos termos.
Steve314
Minha primeira pergunta é se eu sei o que estou fazendo ou não. Se sim, posso projetar as coisas com antecedência e a digitação estática faz sentido. Caso contrário, terei que mudar muitas coisas rapidamente e a digitação dinâmica será mais fácil. Lisp comum é a melhor linguagem que encontrei quando não sei o que estou fazendo. (Aviso: eu apenas arranhamos Haskell, e, portanto, não têm boa sensação para tipagem estática inferido.)
David Thornley
2
Eu concordo totalmente com John Skeet msmvps.com/blogs/jon_skeet/archive/2009/11/17/…
user

Respostas:

99

Na verdade, acho que é por pouco. Tanto a digitação dinâmica quanto a estática têm suas vantagens.

Razões para a digitação dinâmica ser mais produtiva:

  • É mais conciso - Muito código clichê estranho pode ser removido se tudo for digitado dinamicamente - declarações de tipo, lógica de conversão de texto etc. Todas as outras coisas são iguais, o código mais curto é marginalmente mais rápido de escrever, mas o mais importante é que pode ser mais rápido de ler e ler. manter (já que você não precisa percorrer muitas páginas de código para entender o que está acontecendo)
  • Técnicas mais fáceis de "hackear" , como digitação de patos e patches de macacos, podem obter resultados muito rapidamente (embora possam confundi-lo mais tarde ...)
  • Mais interativo - a digitação dinâmica é provavelmente mais adequada para programação interativa, semelhante a REPL, para prototipagem rápida, depuração em tempo real de instâncias de programas em execução ou até codificação ao vivo.
  • Os casos de teste podem detectar os erros de tempo de execução - supondo que você esteja usando TDD ou, no mínimo, tenha um bom conjunto de testes, isso deve detectar qualquer problema de digitação no seu código.
  • Melhor polimorfismo - as linguagens dinâmicas têm mais chances de incentivar a criação de funções e abstrações polimórficas, o que pode aumentar a produtividade e a reutilização de código. Clojure, por exemplo, faz um ótimo uso do polimorfismo dinâmico em suas muitas abstrações .
  • Protótipos - modelos de dados / objetos baseados em protótipos são, a meu ver, mais poderosos e flexíveis do que as hierarquias de herança com tipo estatístico. É provável que as linguagens dinâmicas permitam ou incentivem uma abordagem baseada em protótipo, sendo o Javascript um ótimo exemplo.

Razões para a digitação estática ser mais produtiva:

  • Melhor design - ser forçado a pensar sobre os tipos de valores em seu software antecipadamente pode levá-lo a soluções mais limpas e lógicas. (Eu digo can - ainda é possível criar código muito ruim ...)
  • Melhor verificação do tempo de compilação - a digitação estática pode permitir que mais erros sejam detectados no momento da compilação. Essa é uma grande vantagem e é, sem dúvida, a melhor coisa sobre linguagens de tipo estaticamente em geral.
  • Preenchimento automático - a digitação estática também pode fornecer mais informações ao IDE, para que o preenchimento automático de pesquisa de código ou documentação seja mais eficaz.
  • Desencoraja hacks - você precisa manter a disciplina de tipo no seu código, o que provavelmente será uma vantagem para a manutenção a longo prazo.
  • Inferência de tipo - em alguns idiomas (por exemplo, Scala), você pode obter muitos dos benefícios concisos das linguagens dinâmicas ainda mantendo a disciplina de tipo.

Em média, minha conclusão (após muitos anos de experiência em ambos os lados da barreira) é que a digitação dinâmica pode ser mais produtiva a curto prazo, mas acaba se tornando difícil de manter, a menos que você tenha muito bons conjuntos de testes e disciplina de teste.

Por outro lado, na verdade, prefiro abordagens de tipo estatístico em geral, porque acho que os benefícios da correção e o suporte à ferramenta oferecem melhor produtividade a longo prazo.

Mikera
fonte
14
+1, resposta muito detalhada. O valor do ponto "Melhor verificação do tempo de compilação" não pode ser estressado o suficiente.
NoChance
8
Juntamente com a Inferência de Tipo, também há sobrecarga no estilo Haskell, modelos C ++, genéricos e talvez alguns outros recursos de linguagem que oferecem algumas das vantagens da digitação Duck dentro de uma estrutura de digitação estática - desde que o objeto forneça a interface necessária (ele "grasnado como um pato"), você pode usá-lo, quase independentemente daquele tipo de objeto nominal. O "quase" é porque algumas abordagens exigem algum tipo de declaração "desse tipo charlatão, como o tipo relevante de pato" - por exemplo, a declaração de "classe" em Haskell.
Steve314
45
Eu tenho que discordar totalmente de sua afirmação de que "código mais curto ... é mais rápido de ler e manter". Há uma etapa intermediária, entendendo o código. Eu tive que manter o código de outras pessoas tanto em Delphi quanto em JavaScript, e o código Delphi é muito mais fácil de entender porque é mais detalhado. E principalmente porque o código Delphi possui declarações de tipo e o JavaScript não. Ao lidar com algo mais complexo que primitivo, as declarações de tipo tornam trivial ver quais são suas variáveis ​​e o que elas podem fazer, o que é um conhecimento essencial para o trabalho de manutenção.
Mason Wheeler
21
Eu imploro para discordar da maioria das razões apresentadas aqui. Veja o Haskell, que provavelmente possui um sistema de tipos mais rigoroso por aí. Possui um REPL (na verdade, pelo menos dois), apresenta um polimorfismo muito poderoso ao fazer a correspondência de padrões em construtores e é tão conciso quanto se pode esperar - muito mais que Javascript ou Python. Então, acho que algumas das razões pelas quais você menciona são acidentais, e não inerentes a linguagens de tipos vagos.
187 Andrea Andrea
15
Eu não confiaria muito em "casos de teste". Você não pode compará-los com um bom sistema de tipos. Um sistema de tipos fornece uma prova de que sua função já será chamada com pelo menos parâmetros corretos, enquanto casos de teste podem fornecer apenas evidências empíricas. No entanto, mesmo essas evidências são coletadas de um cenário artificial.
Ingo
56

Com idiomas dinâmicos, você pode escrever códigos de baixa qualidade mais rapidamente do que quando usa um idioma digitado.

Depois de criar rapidamente sua enorme pilha de coisas dinâmicas, você pode passar com segurança para outro projeto sem ter que se preocupar com manutenção a longo prazo.

Isso é ganho de produtividade :)

Estou brincando, mas depois de me envolver em um projeto usando 'linguagem dinâmica', fiquei assustado com a quantidade de testes, documentações e convenções desnecessárias com as quais você precisa lidar se quiser ter um produto em funcionamento.
E com a alegria de muitos erros de execução que poderiam ter sido detectados na compilação.
Ah, eu também esqueci de falar sobre todos esses hacks e voodoos que a metaprogramação permite que você introduza no seu código!

Portanto, o ganho de produtividade pode ser um mito para projetos médios / grandes ao longo de sua vida útil.

Guillaume
fonte
11
Sim, minha experiência é a mesma. Um script perl de 100 linhas está ok, e sem essas excelentes ferramentas, estávamos perdidos. Mas um projeto perl de 100 mil linhas provavelmente será um pesadelo.
Ingo
3
... e você tem JavaScript (não apenas dinâmico, mas também com pouca digitação).
Den
16

Também existe uma visão teórica para esse problema: um sistema de tipo estático é essencialmente um provador de teoremas especializado que só aceita o programa quando pode provar a correção de tipo dele. Todos os sistemas de tipo estático rejeitam alguns programas válidos porque nenhum sistema de tipo estático decidível é poderoso o suficiente para provar todos os programas possíveis de correção de tipo.

Pode-se argumentar que os programas que não são prováveis ​​por um typechecker estático são hacks e / ou estilo ruim, mas se você já possui um programa válido e o typechecker não o aceita, certamente está prejudicando sua produtividade no curto prazo.

Alguns casos em que você pode notar que o verificador de tipo está atrapalhando são contêineres genéricos e co / contravariância em argumentos e tipos de retorno.

Patrick
fonte
18
Por outro lado, se você digitou erroneamente um programa incorreto , o compilador informa imediatamente e destaca a linha incorreta. isso melhora sua produtividade, quando comparado a perceber uma execução de teste com falha e depuração para encontrar o erro.
MarkJ
5
contêineres genéricos e co-contravariância explícita devem "atrapalhar" se você fizer errado. qual é o benefício de compilar código que falhará no tempo de execução?
M.Stramm
Normalmente, o trabalho é considerado 0% concluído até que todos os testes sejam executados com êxito. Só então seu progresso pode ser considerado mais do que nada. Com isso em mente, acho que não vale a pena medir sua produtividade em algo que ainda não foi finalizado.
Pijusn 26/03
-1 Não aborda a questão real ("ganhos de produtividade", lembra?) Além disso, você provavelmente nem deseja escrever esses "programas válidos que o sistema de tipos rejeita". Só porque você pode, não significa que deveria. E por que você ainda teria um "programa válido" que o typechecker rejeita? Você estava codificando um programa Javascript e subitamente tentou compilá-lo em Java?
18715 Andres F.19:
Os programas válidos que o sistema de tipos rejeita podem ajudar a reduzir o código, levando a menos erros que o sistema de tipos não consegue descobrir (menos código = menos erros). O compilador / IDE que destaca a linha pode ser feito em linguagens dinâmicas com valores de teste (ou seja, desenvolvimento orientado a REPL), para que você possa ver os valores intermediários, e eles podem detectar erros que seu sistema de tipos não pode, assim como erros de tipo. Você também pode usar inferência estática de tipo para fornecer avisos de tipo.
aoeu256 03/10
15

Uma vantagem que encontrei nas linguagens mais dinâmicas é que elas facilitam a escrita de códigos mais genéricos. É muito mais fácil escrever em um nível mais alto de abstração quando você não precisa combater o sistema de tipos para fazer isso.

Você não precisa pensar muito sobre isso - escrever código que faz algo não trivial com qualquer objeto em Java é difícil e provavelmente requer reflexão, tipicamente dinamicamente digitada; com algo como JavaScript, escrever uma função que faz algo interessante para todos os objetos é uma segunda natureza. Um exemplo perfeito seria uma função que escrevi recentemente que pega um objeto e substitui todos os seus métodos por outros que fazem a mesma coisa, mas também acionam um evento. Não tenho idéia de como abordar algo assim em Java. No entanto, não sei quanto disso se deve aos sistemas de tipos e quanto a outras diferenças de idioma.

No entanto, recentemente comecei a usar o Haskell. Haskell me permite escrever um código genérico abstrato, tão facilmente quanto qualquer linguagem dinamicamente usada. Meu exemplo de Java / JavaScript acima não faz sentido no Haskell porque não possui objetos, métodos, eventos ou mesmo muita mutação, mas outros tipos de código genérico são realmente fáceis de escrever.

De fato, Haskell pode escrever um código genérico que as linguagens dinamicamente digitadas não podem; um exemplo perfeito é a readfunção que é basicamente o oposto de toString. Você pode obter um Intou um Doubleou qualquer tipo que desejar (desde que esteja em uma determinada classe de tipo). Você pode até ter polimórficos constantes , por isso maxBoundpode ser o máximo Int, Double, Char... etc., Tudo dependendo de que tipo é suposto ser.

Minha teoria agora é que o ganho de produtividade ao usar uma linguagem dinâmica é sempre comparado a linguagens como Java, com sistemas do tipo menos capazes, mais detalhados e menos flexíveis.

No entanto, mesmo o sistema de tipos de Haskell tem alguns problemas irritantes que você não teria em um idioma digitado dinamicamente. O maior que me incomoda é a maneira como os números são tratados; por exemplo, você precisa mexer no sistema de tipos para usar length(de uma lista) como um duplo, algo com o qual você não teria problemas sem um sistema de tipos. Outra coisa irritante em que me deparei é trabalhar com Word8(um tipo int não assinado) e funções que esperamos Int.

Portanto, não ter um sistema de tipos facilita escrever código genérico sem pensar muito e também evita armadilhas irritantes dos sistemas de tipos. Você nunca precisa combater o sistema de tipos em uma linguagem dinâmica, mas também não pode confiar nele.

Tikhon Jelvis
fonte
1
Sim, por algum motivo, é difícil acertar os sistemas numéricos. Na Scala, também é uma bagunça. Penso que os sistemas dinâmicos vencem sistemas de tipos estáticos simples em termos de facilidade de trabalhar com eles, mas perdem os mais avançados (como Scala, Haskell, ML etc, que usam variantes do sistema-F ).
Edgar Klerks
3
Sua resposta é bem-intencionada, mas com erros. Primeiro, não é verdade que as linguagens dinâmicas "não têm sistema de tipos", de modo que não pode ser o motivo pelo qual elas "facilitam a gravação de código genérico". Eles não facilitam, como mostra seu próprio contra-exemplo com Haskell (você desmascara sua própria afirmação!). "Você nunca precisa lutar contra o sistema de tipos" é falso: você luta sempre que precisa corrigir um bug causado por uma digitação estática insuficiente. Finalmente, coagir explicitamente o Intretornado por uma lista é trivial; exemplo 1.0 + fromIntegral (length myList):, ou seja, basta usar fromIntegral.
19715 Andres F.
2
Finalmente, "escrevendo código rápido"! = "Sendo mais produtivo". Seu código precisa funcionar! Se você escreve um software de buggy, que deve ser gasto posteriormente depurando e corrigindo, não estará sendo produtivo.
19715 Andres F.
"sem pensar muito" bandeira vermelha para o que a maioria das pessoas querem dizer quando falam sobre linguagens digitadas dinamicamente sendo "mais produtivo"
Ataraxia
Se os sistemas de tipos realmente melhoraram a produtividade, onde estão todos os aplicativos úteis em Haskell ou Idris? Eu acho que coisas como é fácil entender o erro de tipo, "patchability" (capacidade de editar seu aplicativo de maneiras imprevisíveis) e 90% de verificação de erros de documentos e inferência de tipos podem ser mais importantes.
aoeu256 03/10
7

P: Ouvi muitas vezes a afirmação de que as linguagens dinamicamente digitadas são mais produtivas que as linguagens estaticamente. Quais são as razões para esta reivindicação? "

Isso tem razões históricas. Se você voltar algumas décadas, as linguagens dinâmicas eram indiscutivelmente mais produtivas que as linguagens estáticas (embora também significativamente mais lentas). Perl é claramente muito mais produtivo que C, se você conhece os dois e a tarefa em questão permite isso. Porém, com o tempo, os idiomas se emprestaram muito e os idiomas mais novos estão diminuindo a diferença (tanto em produtividade quanto em desempenho).

Aqui estão alguns pontos a considerar:

Coleta de lixo : A coleta de lixo é um enorme aumento de produtividade. Eu acredito que Java foi a primeira linguagem estática mainstream com GC. Antes disso, estática significava basicamente gerenciamento manual de memória. (Nota: Aqui e a seguir, considero apenas as principais linguagens. Existem muitas linguagens experimentais e de nicho que fornecerão contra-exemplos a qualquer ponto que eu faça.)

Segurança da memória : é uma melhoria de produtividade que você não precisa se preocupar em dar um tiro no próprio pé. Antes de linguagens estáticas "gerenciadas" como Java, estática normalmente significava acesso direto à memória. A depuração também faz parte da produtividade, e o acesso inseguro à memória pode levar a erros realmente obscuros.

Sistemas de tipo pesado. Antes da introdução de tipos parametrizados (como modelos ou genéricos) em linguagens estáticas, as limitações dos sistemas de tipos estáticos costumavam ser um fardo. Por exemplo, em Java, era necessário fazer o downcast explicitamente toda vez que você selecionava um item de uma coleção. Então você tem a sobrecarga sintática de um elenco e nenhum tipo de segurança. Considerando o quão onipresente as coleções são na programação, essa foi uma grande desvantagem.
Ter que declarar o tipo de tudo é muita digitação redundante, mas com a inferência de tipo moderna, isso pode ser reduzido significativamente.

Grande biblioteca padrão. O Python foi anunciado como "baterias incluídas" por causa da grande biblioteca padrão. Isso em comparação com C, que tem uma biblioteca padrão muito minimalista. Mas com plataformas como Java e .net, uma vasta biblioteca padrão está se tornando padrão, e linguagens mais recentes como Scala e F # estão herdando isso "de graça".

Estruturas de dados de primeira classe. Linguagens dinâmicas como Perl e Python possuem estruturas de dados de primeira classe, como listas e mapas, com atalhos sintáticos convenientes para operações comuns. Comparado a isso, C não tem coleções internas, exceto matrizes de tamanho fixo.

Encerramentos e sintaxe lambda - linguagens dinâmicas normalmente têm isso desde o início, mas linguagens estáticas adotam isso, mais recentemente Java.

A capacidade do REPL de testar rapidamente trechos de código de maneira interativa é um grande benefício. Porém, embora as ferramentas IDE, como a janela "imediata" no Visual Studio, as linguagens estáticas possam emular isso até certo ponto.

Ferramentas avançadas - além dos pontos acima em que as linguagens estáticas estão se aproximando da conveniência das linguagens dinâmicas, os editores modernos estão aproveitando a análise estática de uma maneira que as linguagens dinâmicas enfrentam dificuldades. Por exemplo, os editores podem fornecer refatorações automáticas seguras, algo estritamente impossível em um idioma dinâmico.

Conclusão: Historicamente era verdade, mas hoje a resposta é menos clara.


P: Então: o que há para dizer com relação à produtividade com a digitação dinâmica, que realmente é uma vantagem do próprio modelo de texto?

É um pouco difícil separar o modelo de digitação dinâmica das linguagens dinâmicas, mas, como exemplo, o C # adotou mais recursos mais dinâmicos ao longo do tempo, mesmo que seu núcleo seja uma linguagem estática. Esta é realmente uma prova de benefício do modelo de tipo dinâmico. Exemplos:

Reflexão A reflexão é fundamentalmente um recurso de digitação dinâmica. Você inspeciona os tipos de objetos no runtime rater do que no tempo de compilação. Quando foi introduzido, era meio que desaprovado, mas em C # o uso da reflexão se torna cada vez mais onipresente, por exemplo, o ASP.Net MVC usa a reflexão fortemente.

Atributos Atributos são um exemplo de digitação dinâmica. Você pode adicionar atributos arbitrários a uma classe em tempo de compilação e depois inspecionar em tempo de execução (por meio de reflexão) e manipular objetos com base nela. Algo como o MEP é basicamente uma estrutura de extensão baseada em um modelo de tipo dinâmico.

Linq para SQL, EF mv. Os vários transformadores do Linq inspecionam consultas como objetos de tempo de execução e geram sql em tempo real. Não fica mais dinâmico do que inspecionar o código em tempo de execução. CodeDom é o outro lado da moeda, onde o código pode ser gerado em tempo de execução

Roslyn Roslyn basicamente implementa eval, que já foi considerado o recurso definidor de uma linguagem verdadeiramente dinâmica.

Dinâmico O dynamictipo-é o recurso mais explicitamente dinâmico em C # e é anunciado para tornar a interação com objetos e linguagens externas mais simples e produtivas. Mas também é usado no MVC do Asp.net por conveniência.

O benefício de todos os recursos acima mostra que o modelo dinâmico possui vantagens definidas, mesmo em uma linguagem estática, com tipos parametrizados, tipos estruturais e inferência de tipos.

JacquesB
fonte
Eu realmente não gosto desta resposta, porque quase todos os pontos não abordam a questão principal: "Qual é o suposto ganho de produtividade da digitação dinâmica ?" linguagens não dinâmicas .
Nanny
@nanny, você poderia elaborar sua diferença percebida entre linguagens dinâmicas digitadas e linguagens dinâmicas? (é uma daquelas coisas confusas). Você poderia dar um exemplo de uma linguagem de tipo dinâmico que não é uma linguagem dinâmica, além de definições claras de cada uma?
@ nanny: A pergunta realmente pergunta sobre "linguagens dinamicamente tipadas", não apenas "digitação dinâmica".
perfil completo de Jacques
@MichaelT Desculpe, eu não estava claro. A digitação dinâmica é um aspecto de todos os idiomas dinâmicos. Esta resposta está falando de outros aspectos que, historicamente, linguagens dinâmicas tendem a aparecer, sem realmente abordar a parte da digitação dinâmica.
Nanny
1
@ nanny: Eu estou basicamente respondendo a isso: "Eu sempre ouvi a afirmação de que as linguagens dinamicamente digitadas são mais produtivas do que as linguagens estaticamente. Quais são as razões dessa alegação?" - Acredito que as razões para esta reivindicação sejam históricas e relacionadas não apenas à digitação dinâmica, mas também a outros recursos para melhorar a produtividade das linguagens dinâmicas.
perfil completo de Jacques
6

O conjunto de todos os recursos da linguagem moderna é tão grande que apenas a digitação estática versus a dinâmica não tem muito peso.

A regra é: quanto melhor o seu idioma, menor o seu código. Isso é bem simples. Java mostra como a digitação estática pode dar muito errado, o que dá aos seus oponentes muito para se alimentar. Recursos de linguagem mal projetados geralmente têm um custo, e a digitação estática em Java é primeiramente um recurso obrigatório (caso contrário, a maioria das pessoas provavelmente nem o usaria) e, em segundo lugar, mal executada.
É por isso que, em comparação, a maioria das linguagens dinâmicas brilha, mesmo que eu argumentasse que o PHP realmente não melhora sua vida no total geral (pelo menos até recentemente), por causa de muitas outras peculiaridades não relacionadas aos sistemas de tipos.

Por outro lado, você tem muitos idiomas com sistemas de tipos expressivos que não atrapalham e que nem são obrigatórios. E alguns deles até permitem a incorporação de código não digitado, sempre que você precisar escapar do sistema de tipos.

Pessoalmente, uso o haXe, que é uma linguagem com inferência de tipos, subtipo nominal e estrutural, código opcional não tipado, tipos de funções de primeira classe, tipos de dados algébricos e macros lexicais (não muito maduras, mas extremamente poderosas), evitando a sintaxe arcana. Depois de usar o haXe há cerca de 3 anos, cheguei a uma conclusão simples:

A programação se torna muito mais fácil, quando sua linguagem não o prende em escolhas religiosas sobre paradigmas, mas tenta ser apenas uma boa ferramenta. Existem várias linguagens estáticas e dinâmicas e linguagens mistas que obtêm sucesso. Alguns deles são fáceis de aprender, mais difíceis de dominar.
Seu poder vem da maneira como seus recursos individuais podem ser compostos para criar facilmente soluções simples para problemas complexos. Isso exclui uma certa ortogonalidade que só pode ser alcançada através de um delicado equilíbrio de inclusão ou omissão de todos os recursos de linguagem explorados até agora. Se você tentasse adicionar uma digitação estática ao Ruby, você o prejudicaria; se tentasse afastá-lo de Haskell, o esmagaria. Em contraste com isso: se você o tirasse do C, as pessoas dificilmente perceberiam e se você o tirasse do Java, alguns podem agradecer.

Pela minha experiência pessoal, posso lhe dizer: eu gosto de Ruby. Ampliou meus horizontes e a maneira como projeto sistemas. IMHO deve ser usado para ensinar as pessoas a programar em primeiro lugar. É discreto, poderoso, conciso, divertido. Entendo por que alguém vindo de uma língua ortodoxa vai gostar.
No entanto, a longo prazo, a digitação estática permite adiar o trabalho para o analisador estático e, com inferência de tipo, isso ocorre basicamente sem nenhum custo. O resultado é um código que é mais fácil de manter e geralmente é executado mais rapidamente.

Mas, novamente, a digitação estática sozinha não pode fazer nada. É uma questão de combinação. Eu acho que em algum lugar entre F #, Scala, Nemerle, OCaml ou haXe, você pode encontrar o seu próprio ótimo. Mas isso depende de você, porque o idioma deve permitir que você incorpore seus pensamentos sem esforço, em vez de forçá-lo a dobrá-los. E, afinal, nada produz mais ganho de produtividade do que se a programação fosse divertida.

back2dos
fonte
"A regra é: quanto melhor o seu idioma, menor o seu código." Isso pode estar relacionado à opinião em algum nível, mas não acho que essa afirmação seja precisa. O código mais curto não oferece muitas vantagens por si só, além de envolver menos digitação no momento da gravação e talvez ocupar menos espaço em disco (o que, de qualquer forma, não é fator nas linguagens compiladas). Eu acho que a marca de uma boa linguagem está transmitindo o máximo de informações sobre o que está fazendo da maneira mais concisa possível. Tipagem dinâmica não é muito auto-documentado e perde manutenção como resultado imo
Ataraxia
Você pode suplementar código digitado dinâmico com informações como valores padrão / argumentos de palavra-chave, tipos obtidos de inferência de tipo, inferência de tipo dinâmico de um compilador JIT ou apenas registrar todas as funções [passar por todas as funções ou classes em um programa em execução e substituí-las por um versão da função que registra seus argumentos / resultados). Então você pode ver o log das execuções anteriores de uma função. Outra idéia é rejeitar o código que não possui anotações de tipo, contratos de tempo de execução ou exemplos de testes de sessão REPL, mas oferece ao desenvolvedor a opção de escolher qualquer um dos três.
aoeu256 03/10
3

Pessoalmente, a única razão pela qual a digitação dinâmica ajudaria é se você é um datilógrafo muito lento ou cria funções / métodos / métodos gigantes, difíceis de navegar. Você também precisa entrar em toda a questão dos testes de unidade. Os tipos dinâmicos exigem (a menos que você goste de escrever código quebrado) testes de unidade vigorosos (para garantir que seus tipos dinâmicos não explodam inesperadamente (ou seja, a variável é principalmente duck, mas dcuk acidentalmente às vezes)). A estática tentará muito mais evitar isso (e sim, você pode argumentar a favor de testes de unidade vigorosos)

Paulo
fonte
0

Acho que, antes de tudo, você precisa definir "produtividade". O que significa "produtividade" significa e inclui?

Se por "mais produtivo" você quer dizer escrever menos linhas de código para implementar o mesmo recurso, então sim, as linguagens de programação de digitação dinâmica são mais "produtivas" do que as linguagens de estática.

No entanto, se você também considerar o tempo gasto na depuração e correção de bugs, as linguagens de digitação dinâmica podem não ser tão produtivas, porque as linguagens de digitação dinâmica tendem a levar a verificação de erros para o tempo de execução, enquanto, por outro lado, as linguagens de digitação estática pode executar alguma verificação de erro no tempo de compilação. Como é geralmente aceito que, geralmente, quanto mais tarde um bug é encontrado, mais caro é corrigi-lo. Portanto, o código de digitação dinâmica pode resultar em geralmente igual ou talvez até menor que a produtividade do que o código de digitação estática.

yaobin
fonte
Em geral, não é verdade que você pode escrever um recurso em menos linhas usando uma linguagem dinâmica. Quais idiomas você está comparando?
19715 Andres F.
@AndresF. Ah, eu uso principalmente Python e C ++.
yaobin
1
Ok, mas você não pode generalizar a dinâmica versus a estática ao comparar o Python e o C ++. C ++ não é um exemplo particularmente representativo de uma linguagem com digitação estática. Existem linguagens estaticamente extremamente concisas, que mais ou menos permitem que você escreva programas tão breves quanto no Python. Então, em geral, sua afirmação é falsa.
Andres F.
Sim, mas e se você editar seu programa enquanto ele ainda estiver em execução? Qualquer problema de tempo de execução simplesmente ocorrerá e você poderá corrigi-los ali mesmo. No Lisp, sempre que você receber um erro, poderá consertar o programa e continuar executando-o ... Sim, para caminhos mais complexos, as anotações de tipo seriam boas [talvez você possa usar a digitação gradual como mypy & lisp], mas esses caminhos mais complexos também tem a possibilidade de erros que não são do tipo, portanto, evitar caminhos complexos em qualquer idioma pode ser uma boa idéia.
aoeu256 03/10
-1

A grande vantagem da digitação dinâmica é a produtividade.

Python, Ruby etc. têm muitos outros impulsionadores da produtividade, além da digitação dinâmica (parâmetros padrão, dicionários incorporados nos tipos etc.etc.) O efeito cumulativo na produtividade do programador é impressionante.

As penalidades em termos de velocidade (ou falta de!) E consumo de recursos não são tão ruins quanto você esperaria e, na maioria dos casos, são mais do que compensadas pela velocidade e flexibilidade do desenvolvimento.

Há um (! Muito antiga) de papel sobre o assunto aqui. É um dos poucos estudos realizados adequadamente sobre a produtividade do programador e muitas das conclusões ainda são válidas.

O que (provavelmente) seria diferente seria o estudo a ser realizado hoje:

  1. As JVMs Java melhoraram além do reconhecimento.
  2. Os IDEs modernos teriam melhorado a produtividade dos codificadores C ++ e Java, mas fizeram muito pouca diferença para as linguagens de script.
  3. C # seria incluído e provavelmente estaria no mesmo parque de Java que Java, mas um pouco melhor.

Portanto, a mensagem é que, a menos que o desempenho seja um problema realmente sério, as linguagens dinâmicas aumentarão sua produtividade.

James Anderson
fonte
2
Minha falta de clareza é exatamente o que a digitação dinâmica faz para aumentar sua produtividade. O artigo é interessante, no entanto, trata-se de um programa muito pequeno, e não tenho certeza de como isso passa para os milhares de linhas de código na maioria dos programas.
Hans-Peter Störr
5
Esse estudo usa apenas C, C ++ e Java como exemplos de linguagens estáticas e, em seguida, tenta aplicar as conclusões encontradas nas linguagens de programação tradicionais em geral. Todos os três idiomas compartilham a mesma sintaxe básica, com as mesmas falhas inerentes que diminuem a produtividade, tornando a comparação inválida. Não é que as linguagens estáticas sejam improdutivas, é que a família C é improdutiva. Se tivessem incluído um dialeto Pascal em seus testes, provavelmente teriam chegado a algumas conclusões diferentes.
Mason Wheeler
@ maçom - existem muito poucos estudos objetivos reais neste campo. Este é um dos poucos estudos reais com números reais, etc. O programa "amostra" não é trivial! Ele combina elementos de manipulação de dicionário, algoritmos complexos e grandes volumes de dados. A alta porcentagem de tentativas com falha e travamento confirma a natureza não trivial da tarefa.
James Anderson
2
-1 Você não está dizendo muito sobre o que torna as linguagens dinâmicas digitadas mais produtivas. Os parâmetros e dicionários padrão podem ser encontrados em idiomas estáticos, como, por exemplo, Scala.
Jonas
1
@ JamesAnderson Pior ainda, o artigo ao qual você vinculou nem suporta seu argumento. Ele compara "linguagens de script" (geralmente dinâmicas) com " linguagens convencionais " (geralmente estáticas). Agora, diga-me, o que exatamente são as línguas "convencionais"? Você acha que é o mesmo que o conjunto de idiomas com digitação estática? Pior ainda, o papel não é que de idade. Até o ano 2000, muitas grandes linguagens com tipagem estática que eram indiscutivelmente mais produtivas do que as linguagens dinâmicas já existiam.
Andres F.