Você pode ter muito de "dinâmica" em linguagens dinâmicas?

Question

Nos últimos meses tenho vindo a fazer uma transição a partir de Java, Groovy e eu posso apreciar muitos dos benefícios que ela traz:menos código, fechamentos, construtores, de PATACAS, que, no final, faz o quadro como Grails possível, a facilidade com escárnio, ao escrever os testes, etc.

No entanto, eu tenho sido "acusado" por meus colegas que meu código não é groovy suficiente.Ou seja, eu ainda declarar tipos para meus parâmetros e campos, tendem a usar a herança e polimorfismo em vez de duck typing etc.Parece-me que nestas situações não é só dinâmico vs.estático, mas também dinâmico vs.objeto paradigma orientado tipo de dilema.Nesses casos eu ainda tendem a preferir OO.Eu sinto que o OO tem grande valor na sua premissa básica em que permite o abstrato e se relacionam com o seu código de construções particulares do mundo real conceitos.

Então, aqui estão determinadas perguntas, eu preciso de ajuda com:

1. Devo declarar tipos para meus parâmetros, campos, etc?

2. Devo declarar bloco de código como encerramento, quando um simples método irá fazer?

3. Quando devo usar o duck typing em vez de polimórfico dinâmico de distribuição.Por exemplo, em groovy que eu possa fazer de animais."$a ação"() ou def animal;animais.ação() , em vez do Animal = new Dog();animais.(ação).Eu posso ver o problema com o primeiro lugar no contexto do Aberto-Fechado princípio, mas quaisquer outras razões para preferir o OO estilo de polimorfismo?

4. Quando devo usar interfaces em groovy (se alguma)?

Tenho certeza de que existem outros dilemas semelhantes que eu não escreva.Eu também acho que essas questões são válidas não apenas para groovy, mas para qualquer outra linguagem dinâmica.Qual é a sua opinião?

Answer 1

.1. Devo declarar tipos para meus parâmetros, campos, etc?

Eu tendem a declarar tipos de classes usadas como parte de uma API pública, coisas que outros desenvolvedores consumirão muito ou onde eu gostaria de uma ajuda adicional de preenchimento automático da Intellij. Caso contrário, eu 'def' coisas.

.2. Devo declarar o bloco de código como fechamento quando o método simples servirá?

Eu uso métodos, a menos que seja algo que planejo passar como uma variável. Embora exista o operador de dereferência do método "Foo. & Bar", a maioria dos desenvolvedores não sabe disso e fica confusa com ele quando o encontra. Também uso fechamentos quando é um pequeno pedaço de código que é claro para permanecer em um método maior, em vez de colocar seu próprio método para fins descritivos.

.3. Quando devo usar a digitação de pato em vez de despacho dinâmico polimórfico. Por exemplo, em Groovy, posso fazer animal. "$ Action" () ou def Animal; animal.action (), em vez de animal animal = novo cachorro (); animal.Action (). Eu posso ver o problema primeiro no contexto de princípio de fechamento aberto, mas quaisquer outros motivos para preferir o polimorfismo no estilo OO?

Eu só uso o animal. "$ Action" () quando preciso desse nível de indireção, porque o nome do método varia com base no caminho de execução do código (na maioria das vezes durante a metaprogramação pesada). Eu uso animal animal = novo cachorro (); Animal.Action () Quando eu quero a ajuda do IDE com a conclusão automática, ou esse nível de documentação é útil para a clareza do código (e não prejudicada pela verbosidade extra que pode ser óbvia ou restritiva).

.4. Quando devo usar interfaces no groovy (se alguma vez)?

Eu raramente os uso. Eu pude vê -los principalmente como documentação dos campos esperados para uma chamada de API pública, ou possivelmente como uma interface marcadora para ajudar a distinguir um conjunto de classes de outra de uma perspectiva de metaprogramação. Eles são muito menos úteis no Groovy do que em Java.

Answer 2

Isso nem sempre é uma opinião popular, mas acho que quanto mais explícito e claro seu código, melhor.

Não gosto de construções que deixam você adivinhando exatamente o que está acontecendo ...

Eu trabalhei por um ano em Ruby e não gostei. Não estou dizendo que não tem lugares onde se destaca, estou apenas dizendo que realmente gosto de manter as coisas limpas e explícitas e não senti que Ruby tinha isso como um objetivo.

Uma coisa que eu descobri com certeza-a quantidade de digitação que você faz não equivale à velocidade geral do desenvolvimento. É verdade que uma base de código complicada com muito código repetido contribui para um desenvolvimento muito lento, mas simplesmente reduzir o que você digita sem eliminar a duplicação é inútil, e digitar um código mais claro, claro e explícito geralmente será mais rápido (sobre o sobre duração do projeto) do que o mesmo código escrito em uma linguagem concisa e menos formal.

Se você não acredita que a digitação não tenha relação com a velocidade de desenvolvimento, da próxima vez que você lançar uma contagem de projetos do número de linhas de código e dividir pelos homens gastos (incluindo depuração e teste). Em outras palavras, quanto código foi digitado por dia. Você achará que o resultado é um número muito pequeno-o código de digitação na verdade é uma parte muito pequena de qualquer projeto de software.

Answer 3

Eu acho que com o Groovy você deve favorecer a maneira mais simples de fazer alguma coisa e recorrer aos recursos groovier apenas quando a situação exige. (Como ao escrever macros ou criar multimetóis no Clojure, se você se encontrar muito buscando essas ferramentas, deve se questionar.) Sua abordagem cautelosa me parece bem, possivelmente seus colegas de trabalho estão um pouco intoxicados com seu poder recém-encontrado . (Não seria a primeira vez.)

A coisa boa de ter uma linguagem flexível como o Groovy é que você pode começar com a abordagem cautelosa, como se favoreça, sabendo que tem alternativas mais poderosas para recorrer quando precisar deles. Você sabe, "a coisa mais simples que poderia funcionar".

Mais especificamente, preferir digitar o pato sobre interfaces e não se preocupar com os tipos de parâmetros parece que pode ser uma coisa boa, pode facilitar muito a oferta de zombarias aos testes.

Answer 4

Tudo se resume ao que as pessoas se sentem confortáveis. Eu gosto de usar decretações de tipo e chamadas de método porque me sinto confortável em Java. O código que escrevo deve ser mantido por pessoas sem muita experiência de programação dinâmica, então eu o mantenho perto do código Java normal, a menos que haja um bom motivo para usar um recurso Groovy avançado. Parece que seu grupo deve criar padrões de codificação que tentam explicar quando recursos específicos do Groovy geralmente devem ser usados.

Answer 5

Há dois dominante tipos de linguagens orientadas a objeto.

As línguas no Simula 67 a família, como o C++ e Java, favor estaticamente tipadas variáveis, compiladores e linkers, e o método vtables.

As línguas no Smalltalk a família, como o Rubi, a favor dinamicamente tipada variáveis, interpretação e transmissão de mensagens em vez da função de ponteiro-tabelas.

Ambos são orientados a objeto, mas muito diferentes sobre o conceito de orientação a objeto.

Answer 6

SIM

--

NÃO

Você percebe que não há resposta real para esta pergunta?