IDE per linguaggi dinamici: quanto lontano puoi arrivare?

Trovo frustrante come la velocità di sviluppo che i linguaggi dinamici dovrebbero offrire venga significativamente compromessa dalla mancanza di completamenti e altre risorse che gli IDE ti darebbero nelle loro controparti statiche.

Non si tratta solo di digitare meno: è l'incremento della produttività e il semplice divertimento che si ottiene sfogliando le API senza dover costantemente fare riferimento a una documentazione che non è integrata con l'editor.

Ad oggi tutte le combinazioni linguistiche dinamiche IDE + - che per essere onesti non sono poi così tanto - ho provato sono state:

• passeggino
• lento
• clueless / overthusiastic (come nel mostrare tutti i completamenti possibili)
• o semplicemente non completo come, diciamo, Eclipse + Java.

Sono consapevole che l'analisi dinamica del codice non è un compito banale. Ma non si può fare a meno di chiedersi: è davvero così difficile capire questo pezzo di codice ?

Quindi la mia domanda è:

Qualche IDE particolare (o meno configurazioni all-in-one) ha ottenuto un supporto assolutamente eccezionale per un linguaggio dinamico o è ancora un problema "irrisolto"?

Smalltalk - un linguaggio altamente dinamico - ha sempre avuto un IDE superbo, in cui piccole cose come il refactoring automatico, SUnit (il nonno di tutti i framework * Unit), "chi invia questo messaggio?", "Chi implementa questo metodo?" e simili furono i pionieri. Quindi sì, gli IDE possono davvero supportare linguaggi dinamici a un livello che, fino a poco tempo fa, ha superato di gran lunga quelli dei linguaggi tipizzati staticamente.

S. Lott afferma che "I linguaggi dinamici non possono avere lo stesso tipo di completamento del codice dei linguaggi statici. È sostanzialmente impossibile".

"Essenzialmente impossibile" in senso teorico, assolutista? Sicuro. In senso pratico? Non proprio. Esistono molti modi per dedurre il tipo di linguaggi dinamici, staticamente ( k-CFA , RoelTyper ), in fase di esecuzione ( PIC ) e altri metodi, come l'utilizzo della cronologia recente di un programmatore: "In che modo la cronologia dei programmi può migliorare il completamento del codice" .

Certamente le comunità Pharo e Squeak sono molto contente dei loro strumenti di completamento del codice .

Praticamente tutto ciò che sai dagli IDE è stato sviluppato per la prima volta in Smalltak, che è un linguaggio dinamico. Tutto il resto è solo copiarli. Quindi, chiaramente, tutte queste funzionalità sono possibili in linguaggi dinamici.

Oggi, i linguaggi dinamici sono dietro i linguaggi statici. Ma perché?

Fino a poco tempo fa si pensava quasi universalmente che la digitazione statica fosse superiore alla digitazione dinamica. Molti programmatori hanno cambiato idea più recentemente su questo punto. L'attenzione per gli IDE per le lingue tipizzate in modo dinamico non c'era.

Penso che le funzionalità per gli IDE siano meno utili nelle lingue tipizzate dinamicamente. Quando lavoro in Java o Objective-C, ritengo che l'IDE sia necessario per aiutarmi a lavorare con il linguaggio, ma lo stesso non vale per i linguaggi dinamici.

Alcune parti dell'attività sono più facili in un linguaggio statico. È semplice capire il tipo di espressione. Fare lo stesso in un linguaggio dinamico richiede l'analisi dell'intero programma o la registrazione dei tipi durante il runtime. Poiché molto di ciò che l'IDE ruota attorno ai tipi, ciò ha un effetto.

Mi sono imbattuto in quel problema con Python, in un certo senso. Volevo vim come mio editor, ma ciò significava che non avrei avuto un ambiente IDE. Quindi, ho realizzato il mio con i plugin di VIM. Attualmente, penso di avere effettivamente un ambiente migliore per lo sviluppo di qualsiasi IDE che ho usato in passato.

La mia installazione è ospitata su github , sentiti libero di dare un'occhiata e culla come preferisci. Per una rapida panoramica dei plugin:

• patogeno
• modalità Python, per l'integrazione con corda, pyflakes e pydoc
• vimpdb per un debugger python
• progetto per un elenco di file in un progetto
• taglist per saltare i tag
• supertab per il completamento delle schede
• cecchino per frammenti
• conqueterm per una shell integrata, prompt dei comandi, bash, python o ipython

Ci sono altre cose, ma ha tutte le caratteristiche che hanno gli IDE più popolari. Non mi è costato un centesimo e posso sfruttare tutto il potere di Vim. Split, comandi di movimento, registri, salti, essere in grado di eseguire il mio intero ambiente di sviluppo con la tastiera ...

Se qualche IDE particolare (o meno configurazioni all-in-one) ha ottenuto un supporto assolutamente eccezionale per un linguaggio dinamico,

Considerando che la tua valutazione è difficile da capire ("totalmente eccezionale"? "Clueless / overthusiastic"?) È dubbio che qualsiasi IDE possa corrispondere allo standard implicito.

Il confronto decisivo con Eclipse + Java è sciocco perché i linguaggi dinamici non sono Java.

o è ancora un problema "irrisolto"?

Non proprio.

Probabilmente è irrisolvibile. I tuoi requisiti ("mancanza di completamenti e altre risorse") rendono difficile essere più precisi.

I linguaggi dinamici non possono avere lo stesso tipo di completamento del codice dei linguaggi statici. È essenzialmente impossibile.

Alcuni IDE fanno un buon lavoro d'ipotesi. Eclipse, ad esempio, ha plugin per linguaggi dinamici.

Penso che questa presentazione di Steve Yegge sia ancora pertinente. in poche parole ci sono alcuni idi di script Java mezzo decenti (intelliJ IDEA), ma i linguaggi dinamici in generale stanno giocando, non perché c'è qualcosa di intrinsecamente più difficile nel rendere questi strumenti (o in effetti i linguaggi) è solo il linguaggio statico ottenuto tutta l'attenzione prima.

Programma tutto il giorno in javascript / php e ruby ​​lavorando su applicazioni web e l'IDE migliore che ho trovato per questo è Aptana. Ha il completamento del codice per tutte e tre le lingue (e Python) raccoglie i miei parametri locali e, soprattutto, quando si lavora con HTML e CSS, raccoglie gli ID in HTML per l'uso in CSS / JavaScript e raccoglie la funzione nomi per quando sto facendo qualcosa di rapido e sporco e scrivendo javascript in linea (lo so male, ma a volte utile per la prova del concetto). Ha attività di rake integrate e supporto integrato per git e una console della riga di comando. Mi ci è voluto un po 'per alzarmi, ma una volta che ho scoperto che non ho quasi mai lasciato il mio IDE durante la programmazione e questo mi fa risparmiare un sacco di tempo.

Ho scoperto che il supporto di Wing IDE per Python è davvero eccezionale. Fa un buon lavoro con il completamento del codice e il suo debugger è potente quanto quello di Visual Studio per il C # non dinamico.

Posso attestare che non è difettoso, lento o all'oscuro. Non ho mai usato Eclipse, quindi sono ignorante su questo punto, ma penso che la domanda più grande sia: esiste qualche barriera intrinseca allo sviluppo di un IDE completo e che migliora la produttività per i linguaggi dinamici. Data la mia esperienza con Python e Wing, sono propenso a dire che non è così. Tuttavia, è certamente più difficile.

Visual Studio di Microsoft è un IDE utilizzato da molti programmatori e supporta IronRuby , IronPython e F #. Molti considererebbero Ruby e Python come un linguaggio di programmazione dinamico, mentre F # lo sarebbe meno.

In risposta al commento, F # è un linguaggio di programmazione.

F # (pronunciato F Sharp) è un linguaggio di programmazione multi-paradigma, rivolto a .NET Framework, che comprende la programmazione funzionale e le discipline di programmazione imperativa e orientata agli oggetti. È una variante di ML ed è ampiamente compatibile con l'implementazione di OCaml.

Mentre l'esatta definizione di ciò che definisce esattamente un "linguaggio dinamico" è ancora oggetto di dibattito, la maggior parte concorderebbe sul fatto che JavaScript è più "dinamico" di C # per esempio. Secondo Wikipedia:

La definizione di un linguaggio dinamico è ambigua perché tenta di fare distinzioni tra codice e dati, nonché tra compilazione e runtime che non sono universali. Le macchine virtuali, la compilazione just-in-time e la capacità di molti linguaggi di programmazione su alcuni sistemi di modificare direttamente il codice macchina rendono la distinzione astratta. In generale, l'affermazione che una lingua è dinamica è più un'affermazione sulla facilità d'uso delle funzionalità dinamiche che una chiara dichiarazione delle capacità della lingua.

Non voglio aprire una lattina di vermi qui. Alcuni suggerirebbero che F # sia descritto più correttamente come un linguaggio funzionale piuttosto che dinamico, e non farei eccezione. Quello che credo sarebbe giusto dire che è dei vari linguaggi .Net, F # è generalmente considerato il più appropriato per la programmazione dinamica rispetto a C # o VB.

Potresti voler vedere: cosa qualifica un linguaggio di programmazione come dinamico?

La principale differenza tra le lingue tipizzate staticamente e le lingue tipizzate dinamicamente è che il sistema può sicuramente sapere cosa significa un riferimento a un simbolo al momento della compilazione.

Questo rende davvero facile raccogliere le informazioni necessarie per creare un buon IDE direttamente dalle informazioni generate dal compilatore al momento della compilazione (che viene semplicemente spostato fino al momento di "modifica" per la maggior parte).

Se hai una firma del metodo autonomo che dice solo che il metodo prende una "Cosa" come può un editor aiutarti a sapere cosa inviare? Come può aiutare a suggerire modi di usare la cosa?

Anche la tipizzazione anatra non aiuta qui - anche l'editor più intelligente possibile non sarà in grado di dirti che semplicemente perché il tuo oggetto ha un metodo .executeFooOp () che può codificare ".executeBarOp" su quell'oggetto (Anche se potrebbe setacciare il resto della base di codice e fare alcune ipotesi intelligenti).

Se sai che è una "stringa" nella firma, tuttavia, conosci tutti i metodi che potresti chiamare su quella stringa E sei in grado di suggerire quella variabile quando quell'utente è nel mezzo della digitazione di una chiamata di metodo che richiede un Stringa come parametro. Potresti anche suggerire sottoclassi in cui potrebbe essere lanciato se lo desideri.

Le informazioni non sono lì con i linguaggi tipizzati dinamicamente a meno che tu non possa fare una scansione completa dell'intera base di codice con qualcosa MOLTO più intelligente del tuo tipico compilatore.

Almeno per PHP molti IDE "comprendono" qualcosa del genere

/** @var $foo ClassA **/

Se documentate in modo standardizzato (in questo caso phpDocumentor ) l'IDE ne trarrà il massimo vantaggio.

Da tutti gli IDE per i linguaggi dinamici (linguaggi che risolvono il tipo in fase di esecuzione) il migliore è ... Visual Studio per Python

• Informazioni sul tipo di bulling per Intellisense
• Navigazione
• debuging

Vale la pena provare.