IDEs para idiomas dinâmicos - até onde você pode chegar?

Acho frustrante como a velocidade de desenvolvimento que as linguagens dinâmicas devem oferecer fica significativamente comprometida pela falta de conclusões e outros ativos que os IDEs dariam a você em suas contrapartidas estáticas.

Não se trata apenas de digitar menos - é o aumento da produtividade e a diversão que você obtém navegando nas APIs sem precisar se referir constantemente a uma documentação que não está integrada ao editor.

Até o momento, todas as combinações de idiomas dinâmicos do IDE +, que para ser justo, não são muito assim, eu tentei foram:

• buggy
• lento
• sem noção / entusiasmado demais (como mostra todas as conclusões possíveis)
• ou simplesmente não tão completo quanto, digamos, Eclipse + Java.

Estou ciente de que a análise dinâmica de código não é uma tarefa trivial. Mas não se pode deixar de pensar - esse pedaço de código é realmente tão difícil de descobrir ?

Então, minha pergunta é:

Algum IDEs específico (ou configurações menos all-in-one) alcançou um suporte totalmente excepcional a um idioma dinâmico, ou ainda é um problema "não resolvido"?

O Smalltalk - uma linguagem altamente dinâmica - sempre teve um IDE excelente, no qual pequenas coisas como refatoração automática, SUnit (o avô de todos os * frameworks de unidades), "quem envia esta mensagem?", "Quem implementa esse método?" e similares foram pioneiros. Portanto, sim, os IDEs podem de fato suportar linguagens dinâmicas a um nível que, até muito recentemente, superava em muito as linguagens de tipo estaticamente.

S. Lott diz que "linguagens dinâmicas não podem ter o mesmo tipo de conclusão de código que as linguagens estáticas. É essencialmente impossível".

"Essencialmente impossível" em um sentido teórico, absolutista? Certo. Em um sentido prático? Na verdade não. Existem muitas maneiras de inferir o tipo de linguagens dinâmicas, estaticamente ( k-CFA , RoelTyper ), em tempo de execução ( PICs ) e outros métodos, como o uso do histórico recente de um programador - "Como o histórico do programa pode melhorar a conclusão do código" .

Certamente as comunidades Pharo e Squeak estão muito felizes com suas ferramentas de conclusão de código .

Praticamente tudo o que você sabe dos IDEs foi desenvolvido pela primeira vez no Smalltak, que é uma linguagem dinâmica. Tudo o resto é apenas copiá-los. Tão claramente, todos esses recursos são possíveis em linguagens dinâmicas.

Hoje, as linguagens dinâmicas estão por trás das linguagens estáticas. Mas por que?

Até recentemente, pensava-se universalmente que a digitação estática era superior à digitação dinâmica. Muitos programadores mudaram de idéia mais recentemente sobre esse ponto. O foco nos IDEs para idiomas de tipo dinâmico não estava lá.

Eu acho que os recursos para IDEs são menos úteis em linguagens dinamicamente tipadas. Ao trabalhar em Java ou Objective-C, sinto que o IDE é necessário para me ajudar a trabalhar com a linguagem, mas o mesmo não se aplica às linguagens dinâmicas.

Algumas partes da tarefa são mais fáceis em uma linguagem estática. É simples descobrir o tipo de uma expressão. Fazer o mesmo em uma linguagem dinâmica requer uma análise completa do programa ou o registro dos tipos durante o tempo de execução. Como muito do que o IDE gira em torno dos tipos, isso tem efeito.

Eu encontrei esse problema com python, mais ou menos. Eu queria o vim como meu editor, mas isso significava que eu não teria um ambiente IDE. Então, eu criei meus próprios plugins vim. Atualmente, acho que realmente tenho um ambiente melhor para o desenvolvimento que qualquer IDE que eu usei no passado.

Minha configuração está hospedada no github , fique à vontade para dar uma olhada e usar o que quiser. Para uma rápida visão geral dos plugins:

• patógeno
• modo python, para integração de corda, pyflakes e pydoc
• vimpdb para um depurador python
• projeto para uma lista de arquivos em um projeto
• lista de tags para o salto de tag
• supertab para preenchimento de guias
• snipmate para trechos
• conqueterm para um shell integrado, prompt de comando, bash, python ou ipython

Existem outras coisas, mas ele tem todos os recursos que os IDE mais populares têm. Não me custou um centavo e aproveito todo o poder do vim. Divisões, comandos de movimento, registros, saltos, sendo capaz de executar todo o meu ambiente de desenvolvimento com o teclado ...

Algum IDEs específico (ou configurações menos all-in-one) alcançou um suporte totalmente excepcional a um idioma dinâmico,

Considerando que sua avaliação é difícil de entender ("totalmente extraordinário"? "Sem noção / entusiasta demais"?), É duvidoso que qualquer IDE possa corresponder ao padrão implícito.

A comparação trivial com o Eclipse + Java é tola porque as linguagens dinâmicas não são Java.

ou isso ainda é um problema 'não resolvido'?

Não é bem assim.

Provavelmente é insolúvel. Seus requisitos ("falta de conclusão e outros recursos") dificultam a precisão.

Os idiomas dinâmicos não podem ter o mesmo tipo de conclusão de código que os idiomas estáticos. É essencialmente impossível.

Alguns IDE fazem um bom trabalho de adivinhação. O Eclipse, por exemplo, possui plugins para idiomas dinâmicos.

Eu acho que essa apresentação de Steve Yegge ainda é relevante. em uma casca de noz, existem alguns ids de scripts Java meio decentes (intelliJ IDEA), mas as linguagens dinâmicas em geral estão se atualizando, não porque haja algo inerentemente mais difícil em tornar essas ferramentas (ou mesmo linguagens), são apenas as linguagens estáticas toda a atenção primeiro.

Programei o dia todo em javascript / php e ruby, trabalhando em aplicativos da Web, e o melhor IDE que encontrei para isso é o Aptana. Ele possui autocompletar código para todas as três linguagens (e python), pega meus vars locais e, além disso, ao trabalhar com html e css, pega id's no html para uso no css / javascript, e pega a função nomes para quando estou fazendo algo rápido e sujo e escrevendo javascript embutido (sei mal, mas às vezes é útil para a prova de conceito). Ele criou tarefas de rake e suporte integrado ao git e um console de linha de comando. Demorei um pouco para me levantar, mas uma vez que descobri que quase nunca saí do meu IDE durante a codificação e isso me economizou muito tempo.

Eu descobri que o suporte do Wing IDE para Python é realmente excelente. Ele faz um bom trabalho com a conclusão de código e seu depurador é tão poderoso quanto o do Visual Studio para o C # não dinâmico.

Eu posso atestar que não é de buggy, lento ou sem noção. Eu nunca usei o Eclipse, por isso sou ignorante nesse ponto, mas acho que a grande questão é: existe alguma barreira inerente ao desenvolvimento de um IDE completo e que aprimore a produtividade para linguagens dinâmicas. Dada a minha experiência com Python e Wing, estou inclinado a dizer que não é o caso. É, no entanto, certamente mais difícil.

O Visual Studio da Microsoft é um IDE usado por muitos programadores e suporta IronRuby , IronPython e F #. A maioria consideraria Ruby e Python uma linguagem de programação dinâmica, enquanto o F # seria menos.

Em resposta ao comentário, F # é uma linguagem de programação.

F # (pronunciado F Sharp) é uma linguagem de programação com vários paradigmas, direcionada ao .NET Framework, que abrange a programação funcional e as disciplinas de programação imperativa e orientada a objetos. É uma variante do ML e é amplamente compatível com a implementação do OCaml.

Embora a definição exata do que define exatamente uma "linguagem dinâmica" ainda esteja em debate, a maioria concorda que o JavaScript é mais "dinâmico" do que o C #, por exemplo. De acordo com a Wikipedia:

A definição de uma linguagem dinâmica é ambígua porque tenta fazer distinções entre código e dados, bem como entre compilação e tempo de execução que não são universais. Máquinas virtuais, compilação just-in-time e a capacidade de muitas linguagens de programação em alguns sistemas modificarem diretamente o código da máquina tornam a distinção abstrata. Em geral, a afirmação de que um idioma é dinâmico é mais uma afirmação sobre a facilidade de uso de recursos dinâmicos do que uma afirmação clara dos recursos do idioma.

Não quero abrir uma lata de vermes aqui. Alguns sugerem que o F # é mais corretamente descrito como uma linguagem funcional do que dinâmica, e eu não faria exceção a isso. O que eu acredito que seria justo dizer que é das várias linguagens .Net, o F # é geralmente considerado o mais apropriado para a programação dinâmica do que o C # ou o VB.

Você pode querer ver: O que qualifica uma linguagem de programação como dinâmica?

A principal diferença entre idiomas tipicamente estatísticos e idiomas dinamicamente é que o sistema pode saber, com certeza, exatamente o que significa uma referência de símbolo em tempo de compilação.

Isso facilita muito a coleta das informações necessárias para criar um bom IDE diretamente das informações geradas pelo compilador no momento da compilação (que é simplesmente movido para o tempo de "edição" na maior parte).

Se você possui uma assinatura de método autônomo que apenas diz que o método possui uma "Coisa", como um editor pode ajudá-lo a saber o que enviar? Como isso pode ajudar a sugerir maneiras de usar a coisa?

A digitação com patos também não ajuda aqui - mesmo o editor mais inteligente possível não será capaz de dizer que, simplesmente porque seu objeto possui um método .executeFooOp (), ele pode concluir ".executeBarOp" nesse objeto. (Embora possa vasculhar o restante da base de código e fazer algumas suposições inteligentes).

Se você sabe que é uma "String" na assinatura, no entanto, conhece todos os métodos que poderá chamar nessa string E poderá sugerir essa variável quando esse usuário estiver no meio da digitação de uma chamada de método que exija um String como um parâmetro. Você pode até sugerir subclasses nas quais ele pode ser convertido, se você quiser.

A informação simplesmente não existe nas linguagens de tipo dinâmico, a menos que você possa fazer uma varredura completa de toda a base de código com algo MUITO mais inteligente que o seu compilador típico.

Pelo menos para o PHP, muitos IDEs "entendem" algo como

/** @var $foo ClassA **/

Se você documentar de maneira padronizada (neste caso, phpDocumentor ), o IDE aproveitará ao máximo.

De todos os IDEs para linguagens dinâmicas (linguagens que resolvem o tipo em tempo de execução), o melhor é ... Visual Studio for Python

• Informações do tipo de marcação para o Intellisense
• Navegação
• Depuração

Vale a pena tentar.