Codice generato IDE

La differenza tra l'IDE che genera automaticamente del codice e la costruzione direttamente nel linguaggio è molto semplice: Posso modificare il codice dopo che l'IDE lo ha generato .

L'IDE può generare un modello di codice per un getter / setter, e quindi sono libero di aggiungere ulteriori funzionalità a quel getter / setter come i miei requisiti dettano. Se il getter / setter fosse una parte integrata della lingua, se mai avessi voluto personalizzare il comportamento, avrei dovuto scrivere io stesso il getter / setter ...

Quando eseguo il codice in Ruby, utilizzo vim e mi sento bene. Voglio dire, non voglio o non ho bisogno di alcun tipo di completamento automatico / generazione di codice.

Dall'altro lato, quando, codice in Java, utilizzo Eclipse (o Netbeans) e non potrei lavorare senza di esso. Ho bisogno di generare facilmente i getter / setter, il grande blocco try / catch, sono felice se l'IDE mi può aiutare con il ciclo per ogni ciclo.

I wonder whether it isn't an attempt to work around some flaws in the language

Getter + setter + variabile per my_var:

attr_accessor :my_var

getter + setter + variabile di Java per myVar:

private String myVar;
public String getMyVar() {
  return myVar;
}
public void setMyVar(String value) {
  myVar = value;
}

Sì, in Java, ho bisogno di per generare quel codice ...

Quindi ... è un tentativo di aggirare alcuni difetti nella lingua? Sono tentato di rispondere SÌ, ma potrei essere troppo di parte ...

Pensa all'ambiguità che introdurrai in praticamente in qualsiasi linguaggio se permetti al compilatore / interprete di indovinare cosa significhi.

Con getter e setter, non sempre vuoi entrambi, ma come lo interpreterà il compilatore / interprete?

Inoltre, quando usi la classe, dovresti ricordare per conto tuo che una certa proprietà è di sola lettura, invece di averla chiaramente nel codice che non puoi usare un setter perché non esiste .

Il linguaggio Groovy fa esattamente questo, getter e setter sono generati al volo. Ma devo ammettere che troppa magia mi fa sempre meravigliare di ciò che il programma fa davvero, dal momento che ci sono troppe cose da tenere a mente che accadono dietro il sipario. I getter e setter espliciti, come generati dall'IDE, rendono un po 'più facile seguire il flusso del programma.

Generazione del codice da una lingua specifica del dominio , per consentirti di concentrarti sulla scrittura di ciò che conta, è buono.

La generazione del codice da un IDE, per creare codice della piastra della caldaia , è un firmare la lingua fa schifo.

Il tuo esempio specifico - generare getter e setter * mostra certamente un problema linguistico.
Dovresti scrivere solo un getter / setter se fa qualcosa - ma se è generico ciò non significa che lasci che l'IDE lo generi, significa che non ne hai bisogno nel codice a tutti . (Non sprecare la potenza del cervello dello sviluppatore per capire se una funzione è generica o se ha una sottile differenza - lascia semplicemente fuori le funzioni "vuote".)

Oh, e mentre la generazione di codice tecnicamente IDE, snippet / templates, cioè digitando fpubstr e ottenendo public string function( ) o equivalente, è anche una forma di generazione immediata basata su DSL, e quindi una buona cosa (un linguaggio reale che aveva comandi come fpubstr / fpubint / fprvint sarebbe orribile da leggere).

_{* Ignorando temporaneamente che getter e setter sono più che probabile un segno di cattivo OO design.}

Non posso migliorare l'eccellente di Charles Petzold "Does Visual Studio Rot The Mind?" ( link ). Penso che l'IDE e la generazione di codice in generale abbiano il loro posto ma se tu come sviluppatore non sai già perché sta facendo quello che sta facendo (nel caso della generazione del codice che hai scritto i modelli tu stesso, preferibilmente) allora stai volando cieco . Essere in grado di costruire qualcosa da zero in un editor di testo è una buona indicazione per capire cosa sta succedendo. Detto questo sarebbe sciocco insistere nel voler scrivere sempre ogni riga da zero ogni volta che devi fare qualcosa.

Per me, mi piacerebbe pensare che gli IDE dovrebbero aiutare gli utenti a generare codici per

• aumenta la velocità di codifica, ad es. generazione di codici (soggettivi) banali
• dare (in una certa misura) un'idea di come determinati "requisiti" possono essere codificati, ad es. modello per tipi di classi specifici

I codici non devono assolutamente essere dati per scontati per adattarsi esattamente a ciò che si desidera.

Tuttavia, i codici generati da editor visuali / procedure guidate (ad esempio, progettista WinForm che genera i file designer.cs) non dovrebbero essere intralciati se non si ha una profonda comprensione di ciò che si sta facendo e preparati a farsi sfondare se influisce sulla capacità dell'editor visivo per visualizzare la vista in fase di progettazione.

Per getter / setter, è vero per Java (che presumo sia ciò di cui si sta parlando) poiché quella lingua non ha proprietà come costrutto linguistico. L'IDE può aiutarti a compensare un po 'questo.

La generazione del codice IDE è indispensabile per generare cose come stub di metodi per endpoint SOAP o classi di serializzazione da uno schema XML. Queste sono cose che sono al di fuori della portata di un linguaggio ma sono certamente nell'ambito di un "ambiente di sviluppo".

Penso che gli utenti di Java siano maldestri, comunque. Ho sempre pensato che dovessero essere più "virtuali": cioè obj.field = value chiama implicitamente obj.setField(value) . Se la classe dichiara un setField() , allora viene usato, altrimenti il tempo di esecuzione ne consegue solo uno. ISTR Ruby fa qualcosa del genere. JSTL EL lo fa, ma genera semplicemente una chiamata a un setter e, in caso contrario, la chiamata fallisce.