Quali sono gli argomenti per / contro la generazione del codice?

Motivi per:

1. È possibile generare un sacco di codice boilerplate (getter / setter, toString (), cancella)
2. La soluzione automatizzata ha meno probabilità di perdere le modifiche dello schema se stai leggendo lo schema per generare il codice. In un ampio set di tabelle / POJO questo può prevenire i bug.
3. Possibilità di generare documentazione API / schema dal tuo codice.
4. Risparmio di tempo nella manutenzione futura del tuo codice base perché puoi generare rapidamente nuovi elementi.

Ragioni contrarie:

1. Ci vuole tempo per scrivere un generatore di codice (e devi ancora scrivere il codice per i requisiti). La mia argomentazione contro questo è il tempo che risparmio nella manutenzione per compensare.
2. Set secondario di codice al di fuori delle tue esigenze da mantenere.
3. Non puoi mai coprire ogni caso nel tuo generatore (quindi ti ritroverai con qualcosa che ti permette di inserire codice personalizzato)
4. Se il progetto è di piccole dimensioni (meno di 25 tabelle), potrebbe essere eccessivo e il risparmio di tempo potrebbe non essere buono come previsto.

EDIT: ho scritto 3 generatori di codice diversi per i progetti e il fattore più importante nel decidere se farlo è stata la dimensione del progetto. L'ho fatto per un progetto più piccolo e non era efficace quanto il generatore per il mantenimento di progetti più grandi (forse è ovvio, ma pensavo di buttarlo lì fuori). Se il progetto è di dimensioni medio-piccole, mi prendo cura di non usarne uno.

Poiché ho creato e mantenuto un sistema di generazione del codice (ABSE) le mie risposte sono probabilmente di parte, ma qui vanno i miei argomenti:

Per:

• Puoi "riutilizzare" te stesso. Crea un generatore, usalo ancora e ancora.
• È possibile aggiornare ripetutamente il generatore e generare codice. Cambia in un posto, aggiorna ovunque.
• Il codice personalizzato di solito è considerato un deterrente, ma se il tuo generatore supporta l'inclusione di un codice personalizzato, questo "mix" può improvvisamente diventare una buona cosa.
• Un esperto crea un generatore di codice, il resto del team può quindi utilizzarlo. Tutti diventano bravi come l'esperto. L'esperto potrebbe non piacere comunque:).

Contro:

• Non adatto ai neofiti. Alzare l'astrazione richiede un buon pensiero e un po 'di esperienza.
• Non adatto allo sviluppo una tantum. Se stai creando, per esempio, uno script PHP solo una volta, un generatore di codice non è mai una buona idea. Tuttavia, puoi ancora generare modelli di linguaggio comuni se ne usi uno continuamente.

Per alcuni aspetti, è già stato fatto in altre lingue. Vedi Hibernate e NHibernate, due librerie che sono utilizzate rispettivamente in Java e .NET Enterprise e che generano SQL.

Lo fanno al volo, piuttosto che producendo file di codice; tuttavia, stanno risolvendo lo stesso problema.

Sarei sorpreso se qualcosa di simile non fosse già stato creato per C ++ .

La generazione del codice tende a diventare qualcosa di simile a un copia-incolla automatizzato; quindi, prima di generare codice, dovresti sempre considerare di scrivere un pezzo di codice che faccia la stessa cosa al volo; per esempio. invece di generare codice che crea un modulo CRUD per una tabella, scrivi qualcosa che genera il modulo in fase di runtime. Se questo è possibile e fattibile, risulterà in un codice (di gran lunga) inferiore ed eviterai tutti i mal di testa che si presentano con il copia-incolla.

Ma nel mondo reale, dobbiamo ammettere che non è sempre possibile o fattibile; in una situazione del genere è ancora molto meglio generare codice piuttosto che scrivere la stessa cosa a mano. Una decisione che deve essere presa molto presto è se pianifichi o meno di modificare manualmente il codice generato. Se è così, l'output dovrebbe essere semplice e diretto, quindi è facile da cambiare. In caso contrario, è necessario includere i punti di estensione che consentono le personalizzazioni senza modificare il codice. Fare ciò è molto più difficile, e se puoi davvero farlo, controlla se non puoi evitare completamente la generazione del codice e creare qualcosa che costruisca l'oggetto desiderato in fase di runtime.