Crei i tuoi generatori di codice?
https://stackoverflow.com/questions/113286
-
02-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
The Pragmatic Programmer sostiene l'uso di generatori di codice. Crei generatori di codice per i tuoi progetti? Se sì, per cosa li usi?
Soluzione
I generatori di codice se usati ampiamente senza argomentazioni corrette rendono il codice meno comprensibile e riducono la manutenibilità (lo stesso con l'SQL dinamico). Personalmente lo sto usando con alcuni degli strumenti ORM, perché il loro uso qui è per lo più ovvio e talvolta per cose come algoritmi ricercatore-parser e analizzatori grammaticali che non sono progettati per essere gestiti "a mano". ultimamente. Cin cin.
Altri suggerimenti
In " Pragmatic Programmer " Hunt e Thomas distinguono tra generatori di codice passivo e attivo.
I generatori passivi vengono eseguiti una sola volta, dopo di che si modifica il risultato.
I generatori attivi vengono eseguiti tutte le volte che lo desideri e non dovresti mai modificare il risultato perché verrà sostituito.
IMO, questi ultimi sono molto più preziosi perché si avvicinano al principio DRY (non ripetere te stesso).
Se le informazioni di input per il tuo programma possono essere divise in due parti, la parte che cambia di rado (A) (come metadati o DSL) e la parte che è diversa ogni volta che si esegue il programma (B) (il live input), è possibile scrivere un programma generatore che accetta solo A come input e scrive un programma ad hoc che accetta solo B come input. (Un altro nome per questo è una valutazione parziale.)
Il programma generatore è più semplice perché deve solo guadare attraverso l'ingresso A, non A e B. Inoltre, non deve essere veloce perché non viene eseguito spesso e non deve preoccuparsi delle perdite di memoria .
Il programma ad-hoc è più veloce perché non deve guadare un input che è quasi sempre lo stesso (A). È più semplice perché deve solo prendere decisioni sull'input B, non su A e B.
È una buona idea che il programma ad hoc generato sia abbastanza leggibile, in modo da poter trovare più facilmente eventuali errori in esso. Una volta rimossi gli errori dal generatore, scompaiono per sempre.
In un progetto a cui ho lavorato, un team ha progettato una complessa applicazione di database con specifiche di progettazione spesse due pollici e un lungo programma di implementazione, pieno di preoccupazioni per le prestazioni. Scrivendo un generatore di codice, due persone hanno svolto il lavoro in tre mesi e gli elenchi dei codici sorgente (in C) erano spessi circa mezzo pollice e il codice generato era così veloce da non essere un problema. Il programma ad hoc è stato rigenerato settimanalmente, a costi irrilevanti.
Quindi generazione di codice attivo, quando puoi usarlo , è vantaggioso per tutti . E penso che non sia un caso che questo sia esattamente ciò che fanno i compilatori.
Nella progettazione hardware, è pratica abbastanza comune farlo a diversi livelli dello "stack". Ad esempio, ho scritto un generatore di codice per emettere Verilog per varie larghezze, topologie e strutture di motori DMA e switch crossbar, perché i costrutti necessari per esprimere questa parametrizzazione non erano ancora maturi nei flussi degli strumenti di sintesi e simulazione.
È anche normale emettere modelli logici fino ai dati di layout per cose molto regolari che possono essere espresse e generate in modo algoritmico, come SRAM, cache e strutture di file di registro.
Ho anche trascorso un bel po 'di tempo a scrivere, in sostanza, un generatore di codice che prendesse una descrizione XML di tutti i registri su un System-on-Chip ed emettesse HTML (sì, sì, so di XSLT, I appena trovato emettendolo programmaticamente per essere più efficiente in termini di tempo), Verilog, SystemVerilog, C, Assembly ecc. " viste " di tali dati per diversi team (progettazione ASIC front-end e back-end, firmware, documentazione, ecc.) da utilizzare (e mantenerli coerenti in virtù di questo singolo XML "codebase"). Conta?
Alla gente piace anche scrivere generatori di codice per es. prendendo descrizioni concise di cose molto comuni, come le macchine a stati finiti, e producendo meccanicamente codice linguistico imperativo più dettagliato per implementarle in modo efficiente (ad esempio tabelle di transizione e codice di attraversamento).
Usiamo generatori di codice per generare classi di entità di dati, oggetti di database (come trigger, proc memorizzati), proxy di servizio ecc. Ovunque vedi un sacco di codice ripetitivo che segue uno schema e un sacco di lavoro manuale, i generatori di codice possono aiutare. Ma non dovresti usarlo troppo nella misura in cui la manutenibilità è un dolore. Alcuni problemi sorgono anche se si desidera rigenerarli.
Strumenti come Visual Studio, Codesmith hanno i propri modelli per la maggior parte delle attività comuni e semplificano questo processo. Ma è facile da implementare da solo.
È spesso utile creare un generatore di codice che generi codice da una specifica, di solito uno che ha regole tabulari regolari. Riduce la possibilità di introdurre un errore tramite un refuso o un'omissione.
Sì, Ho sviluppato il mio generatore di codice per il diametro del protocollo AAA (RFC 3588). Potrebbe generare strutture e API per i messaggi di diametro che leggono da un file XML che descriveva la grammatica dell'applicazione del diametro.
Ciò ha notevolmente ridotto i tempi di sviluppo dell'interfaccia di diametro completo (come SH / CX / RO ecc.).
secondo me un buon linguaggio di programmazione non avrebbe bisogno di generatori di codice perché l'introspezione e la generazione di codice di runtime farebbero parte del linguaggio, ad es. in metaclass python e nuovo modulo ecc.
di solito generano più codice ingestibile nell'uso a lungo termine.
tuttavia, se è assolutamente indispensabile utilizzare un generatore di codice (eclipse VE per lo sviluppo dell'oscillazione è ciò che uso a volte), assicurati di sapere quale codice viene generato. Credetemi, non vorreste codice nella vostra applicazione con cui non avete familiarità.
La scrittura del proprio generatore per il progetto non è efficiente. Invece, usa un generatore come T4, CodeSmith e Zontroy.
T4 è più complesso e devi conoscere un linguaggio di programmazione .Net. Devi scrivere il tuo modello riga per riga e devi completare le operazioni di relazione dei dati da solo. Puoi usarlo su Visual Studio.
CodeSmith è uno strumento funzionale e ci sono molti modelli pronti per l'uso. Si basa su T4 e scrivere il tuo templato richiede troppo tempo come in T4. C'è una versione di prova e una versione commerciale.
Zontroy è un nuovo strumento con un'interfaccia utente intuitiva. Ha il suo linguaggio modello ed è facile da imparare. C'è un mercato dei modelli online e si sta sviluppando. Anche tu puoi fornire modelli e venderli online sul mercato. Ha una versione gratuita e commerciale. Anche la versione gratuita è sufficiente per completare un progetto su media scala.
potrebbero esserci molti generatori di codice là fuori, tuttavia ne creo sempre uno mio per rendere il codice più comprensibile e soddisfare i framework e le linee guida che stiamo utilizzando
Utilizziamo un generatore per tutto il nuovo codice per garantire il rispetto degli standard di codifica.
Di recente abbiamo sostituito il nostro generatore C ++ interno con CodeSmith . Dobbiamo ancora creare i modelli per lo strumento, ma sembra ideale non dover mantenere lo strumento da soli.
Il mio ultimo bisogno di un generatore era un progetto che leggesse i dati dall'hardware e alla fine li inserisse in un'interfaccia utente 'dashboard'. Nel mezzo c'erano modelli, proprietà, presentatori, eventi, interfacce, flag, ecc. Per diversi punti dati. Ho elaborato il framework per un paio di punti dati fino a quando non ero soddisfatto di poter convivere con il design. Quindi, con l'aiuto di alcuni commenti accuratamente posizionati, ho inserito la "generazione" in una macro di Visual Studio, ho modificato e ripulito la macro, aggiunto i punti dati a una funzione nella macro per chiamare la generazione e alla fine ho risparmiato parecchie ore noiose (giorni?).
Non sottovalutare il potere delle macro :)
Ora sto anche cercando di farmi un giro CodeRush capacità di personalizzazione per aiutarmi con alcuni requisiti di generazione locale. Ci sono cose potenti lì dentro se hai bisogno di decisioni al volo quando generi un blocco di codice.
Ho il mio generatore di codice che eseguo su tabelle SQL. Genera le procedure SQL per accedere ai dati, al livello di accesso ai dati e alla logica aziendale. Ha fatto miracoli nello standardizzare il mio codice e le convenzioni di denominazione. Poiché prevede alcuni campi nelle tabelle del database (come una colonna ID e una colonna datetime aggiornata), ha anche aiutato a standardizzare la mia progettazione dei dati.
Quanti ne cerchi? Ne ho creati due maggiori e numerosi minori. Il primo dei principali mi ha permesso di generare programmi di 1500 linee (dare o avere) che avevano una forte somiglianza familiare ma che erano in sintonia con le diverse tabelle di un database - e di farlo velocemente e in modo affidabile.
L'aspetto negativo di un generatore di codice è che se c'è un bug nel codice generato (perché il modello contiene un bug), allora c'è molto da sistemare da fare.
Tuttavia, per i linguaggi o i sistemi in cui è necessario eseguire una codifica quasi ripetitiva, un buon (abbastanza) generatore di codice è un vantaggio (e più un vantaggio che un "doggle").
Sì, ho dovuto mantenerne alcuni. CORBA o qualche altro tipo di interfaccia di comunicazione dell'oggetto è probabilmente la cosa generale a cui penso per primo. Hai delle definizioni degli oggetti che ti vengono fornite dall'interfaccia di cui parlerai, ma devi comunque costruire quegli oggetti nel codice. Costruire ed eseguire un generatore di codice è un modo abbastanza normale per farlo. Questo può diventare una compilazione piuttosto lunga solo per supportare un canale di comunicazione legacy, e poiché c'è una grande tendenza a mettere involucri attorno a CORBA per renderlo più semplice, beh, le cose peggiorano.
In generale se si dispone di una grande quantità di strutture o solo di strutture che cambiano rapidamente e che è necessario utilizzare, ma non è possibile gestire l'hit di prestazioni della costruzione di oggetti attraverso i metadati, quindi scrivere un generatore di codice.
Non riesco a pensare a nessun progetto in cui dovevamo creare da zero i nostri generatori di codice, ma ce ne sono diversi in cui abbiamo usato generatori preesistenti. (Ho usato sia Antlr che Eclipse Modeling Framework per creare parser e modelli in java per software enterprise.) La bellezza dell'uso di un generatore di codice che qualcun altro ha scritto è che gli autori tendono ad essere esperti in quella zona e hanno risolto problemi che non sapevo nemmeno esistesse ancora. Questo mi fa risparmiare tempo e frustrazione.
Quindi, anche se potrei essere in grado di scrivere codice che risolve il problema, posso generare il codice molto più velocemente e ci sono buone probabilità che sarà meno difettoso di qualsiasi cosa io scriva.
Se non hai intenzione di scrivere il codice, ti sentirai a tuo agio con il codice generato da qualcun altro?
È più economico sia a lungo che a lungo termine scrivere il proprio codice o generatore di codice?
Ho scritto un generatore di codice che avrebbe creato centinaia di classi (Java) che avrebbero prodotto dati XML dal database in modo DTD o conforme allo schema. La generazione del codice era generalmente una cosa sola e il codice veniva quindi semplificato con varie regole aziendali, ecc. L'output era per una banca piuttosto pedante.
I generatori di codice risolvono i limiti del linguaggio di programmazione. Personalmente preferisco la riflessione invece dei generatori di codice, ma concordo sul fatto che i generatori di codice sono più flessibili e il codice risultante ovviamente più veloce durante il runtime. Spero che le versioni future di C # includano una sorta di ambiente DSL.
Gli unici generatori di codice che utilizzo sono parser di servizi web. Personalmente sto lontano dai generatori di codice a causa dei problemi di manutenzione per i nuovi dipendenti o un team separato dopo la consegna.
Scrivo i miei generatori di codice, principalmente in T-SQL, che vengono chiamati durante il processo di compilazione.
In base ai dati del meta-modello, generano trigger, registrazione, dichiarazioni C # const, istruzioni INSERT / UPDATE, informazioni sul modello di dati per verificare se l'app è in esecuzione sullo schema del database previsto.
Devo ancora scrivere un generatore di moduli per aumentare la produttività, più specifiche e meno codifica;)
Ho creato alcuni generatori di codice. Avevo un generatore di codice passivo per le stored procedure SQL che utilizzava modelli. Ciò ha generato il 90% delle nostre procedure memorizzate.
Da quando abbiamo effettuato il passaggio a Entity Framework ho creato un codegeneratore attivo utilizzando T4 ( Text Template Transformation Toolkit ) all'interno di Visual Studio. L'ho usato per creare classi parziali di repository di base per le nostre entità. Funziona molto bene e salva un sacco di codice. Uso anche T4 per decorare le classi di entità con determinati attributi.
Uso le funzioni di generazione del codice fornite da EMF - Eclipse Modeling Framework .
I generatori di codice sono davvero utili in molti casi, specialmente quando si esegue il mapping da un formato a un altro. Ho creato generatori di codice per IDL in C ++, tabelle di database per tipi OO e codice di marshalling solo per citarne alcuni.
Penso che il punto che gli autori stanno provando a fare è che se sei uno sviluppatore dovresti essere in grado di far funzionare il computer per te. La generazione di codice è solo un compito ovvio da automatizzare.
Una volta ho lavorato con un ragazzo che ha insistito sul fatto che avrebbe eseguito manualmente la nostra mappatura da IDL a C ++. All'inizio del progetto è stato in grado di tenere il passo, perché il resto di noi stava cercando di capire cosa fare, ma alla fine è diventato un collo di bottiglia. Ho fatto un generatore di codice in Perl e quindi abbiamo praticamente potuto fare il suo "lavoro" tra pochi minuti.
Consulta la nostra " universal " generatore di codice basato sulle trasformazioni del programma.
Sono l'architetto e un implementatore chiave. Vale la pena notare che una frazione significativa di questo generatore viene generata utilizzando questo generatore.
Nei sistemi embedded, a volte è necessario un grosso blocco di dati binari nella memoria flash. Ad esempio, ne ho uno che prende un file di testo contenente glifi dei caratteri bitmap e lo trasforma in una coppia di file .cc / .h che dichiara costanti interessanti (come primo carattere, ultimo carattere, larghezza e altezza del carattere) e quindi i dati effettivi come una grande const statica uint8_t [] .
Cercare di fare una cosa del genere in C ++ stesso, quindi i dati dei caratteri si genererebbero automaticamente sulla compilazione senza un primo passaggio, sarebbe un problema e molto probabilmente illeggibile. La scrittura manuale di un file .o è fuori discussione. Quindi è svelare la carta millimetrata, codificare a mano in binario e digitare tutto questo.
IMHO, questo genere di cose è ciò a cui servono i generatori di codice. Non dimenticare mai che il computer funziona per te, non viceversa.
A proposito, se usi un generatore, sempre sempre sempre includi alcune righe come questa all'inizio e alla fine di ogni file generato:
// This code was automatically generated from Font_foo.txt. DO NOT EDIT THIS FILE.
// If there's a bug, fix the font text file or the generator program, not this file.
Nei nostri progetti utilizziamo il generatore di codice Telosys : http: //www.telosys. org /
Lo abbiamo creato per ridurre la durata dello sviluppo in attività ricorrenti come schermate CRUD, documentazione, ecc ...
Per noi la cosa più importante è essere in grado di personalizzare i modelli del generatore, al fine di creare obiettivi di nuova generazione, se necessario, e personalizzare i modelli esistenti. Ecco perché abbiamo anche creato un editor di modelli (per i file .vm di Velocity). Funziona bene con il generatore di codice Java / Spring / AngularJS e può essere adattato per altri target (PHP, C #, Python, ecc.)
