Qual è il modo migliore per acquisire familiarità con una base di codice di grandi dimensioni? [chiuso]

https://stackoverflow.com/questions/215076

03-07-2019
|

Domanda

Unirsi a una squadra esistente con una base di codice di grandi dimensioni già in atto può essere scoraggiante. Qual è l'approccio migliore;

Broad; prova a ottenere una panoramica generale di come tutto si collega insieme, dal codice
Narrow; concentrarsi su piccole sezioni di codice alla volta, capendo come funzionano completamente
Scegli una funzione da sviluppare e apprendere man mano che procedi
Cerca di ottenere informazioni dettagliate dai diagrammi di classe e uml, se disponibili (e aggiornati)
Qualcos'altro del tutto?

Sto lavorando su quello che è attualmente un'app C ++ di circa 20k line & amp; libreria (Modifica: piccola nel grande schema delle cose!). Nell'industria immagino che riceveresti un'introduzione da un programmatore esperto. Tuttavia, in caso contrario, cosa puoi fare per iniziare ad aggiungere valore il più rapidamente possibile?

-
Riepilogo delle risposte:

Scorri il codice in modalità debug per vedere come funziona
Fai coppia con qualcuno che ha più familiarità con la base di codice di te, a turno per essere la persona che codifica e la persona che guarda / discute. Ruota i partner tra i membri del team in modo che la conoscenza si diffonda.
Scrivi unit test. Inizia con un'affermazione di come pensi che il codice funzionerà. Se risulta come previsto, probabilmente hai capito il codice. Altrimenti, hai un puzzle da risolvere e o una richiesta da fare. (Grazie Donal, questa è un'ottima risposta)
Esegui i test unitari esistenti per il codice funzionale, in modo simile al precedente
Leggi gli UML, i diagrammi di classe generati da Doxygen e altra documentazione per avere un'idea generale del codice.
Apporta piccole modifiche o correzioni di errori, quindi aumenta gradualmente
Prendi appunti e non saltare dentro e iniziare a sviluppare; è più prezioso dedicare tempo a comprendere che generare codice disordinato o inappropriato.

questo post è un duplicato parziale di the-best-way-to-familiarizzare-te-con-un-ereditato-codebase

Soluzione

Inizia con qualche piccola attività, se possibile, esegui il debug del codice attorno al tuo problema. Scorrere il codice in modalità debug è il modo più semplice per imparare come funziona qualcosa.

Altri suggerimenti

Un'altra opzione è scrivere test per le funzionalità che ti interessano. L'impostazione del cablaggio di test è un buon modo per stabilire quali dipendenze ha il sistema e dove risiede il suo stato. Ogni test inizia con un'affermazione sul modo in cui pensi che il sistema dovrebbe funzionare. Se risulta funzionare in questo modo, hai ottenuto qualcosa e hai del codice di esempio funzionante per riprodurlo. Se non funziona in questo modo, hai un puzzle da risolvere e una linea di indagine da seguire.

Una cosa che di solito suggerisco alle persone che non è ancora stata menzionata è che è importante diventare un utente competente della base di codice esistente prima di poter essere uno sviluppatore. Quando i nuovi sviluppatori entrano nel nostro grande progetto software, suggerisco di trascorrere del tempo diventando utenti esperti prima di immergersi nel tentativo di lavorare sul codice.

Forse è ovvio, ma ho visto molte persone provare a saltare nel codice troppo velocemente perché sono ansiosi di iniziare a fare progressi.

Dipende molto dal tipo di studente e dal tipo di programmatore, ma:

In primo luogo, devi avere un'idea di portata e dimensioni. Ciò potrebbe includere documenti skimmer / uml se sono buoni. Se è un progetto a lungo termine e avrai bisogno di una piena comprensione di tutto, potrei effettivamente leggere correttamente i documenti. Ancora una volta, se sono buoni.
Stretto: scegli qualcosa di gestibile e cerca di capirlo. Ottieni un " assaggio " per il codice.
Scegli una funzione, possibilmente diversa da quella che hai appena visto se ti senti sicuro e inizia a fare alcune piccole modifiche.
Iterate: valuta quanto sono andate bene le cose e vedi se puoi trarre vantaggio dalla ripetizione di un primo passo in modo più approfondito.

Associazione con rotazione rigorosa.

Se possibile, mentre si procede con la documentazione / base di codice, provare a utilizzare l'associazione con una rotazione rigorosa. Ciò significa che due di voi siedono insieme per un periodo di tempo prestabilito (diciamo, una sessione di 2 ore), quindi cambiate coppia, una persona continuerà a lavorare su quell'attività mentre l'altra si sposta su un'altra attività con un altro partner.

In coppia raccoglierai entrambi un pezzo di conoscenza, che può quindi essere alimentato ad altri membri del team quando si verifica la rotazione. La cosa positiva di questo è anche che quando una nuova coppia viene riunita, colui che ha lavorato sull'attività (in questo caso, investigando il codice) può quindi riassumere e spiegare i concetti in un modo più facilmente comprensibile. Col passare del tempo, tutti dovrebbero avere un livello di comprensione simile ed eventualmente sperare di evitare "Oh, solo John conosce quel pezzetto di codice" sindrome.

Da quello che posso dire del tuo scenario, hai un buon numero per questo (3 coppie), tuttavia, se sei distribuito o non stai lavorando con lo stesso calendario, è improbabile che sia possibile.

Suggerirei di eseguire Doxygen su di esso per ottenere un diagramma di classe aggiornato, quindi andare avanti per un po '. Questo ti dà una visione veloce che puoi usare mentre ti avvicini e sporchi con il codice.

Sono d'accordo che dipende interamente dal tipo di studente che sei. Detto questo, sono stato in due società che avevano basi di codice molto grandi per cominciare. In genere, lavoro in questo modo:

Se possibile, prima di esaminare uno qualsiasi dei codici funzionali, eseguo test unitari già scritti. Questi possono generalmente aiutare molto. Se non sono disponibili, faccio quanto segue.

In primo luogo, ignoro ampiamente l'implementazione e guardo solo i file di intestazione o solo le interfacce di classe. Cerco di farmi un'idea di quale sia lo scopo di ogni classe. In secondo luogo, vado avanti di un livello nell'implementazione a partire da quella che sembra essere l'area di maggiore importanza. Questo è difficile da valutare, quindi di tanto in tanto inizio in cima e scendo l'elenco dei file. Io chiamo questo primo apprendimento. Dopo questo primo passo, generalmente vado in profondità attraverso il resto del codice. Il primo sguardo di ampiezza aiuta a consolidare / correggere tutte le idee che ho ottenuto dal livello dell'interfaccia, quindi l'aspetto approfondito mi mostra i modelli che sono stati utilizzati per implementare il sistema, nonché le diverse idee di design. Per prima cosa, intendo che sostanzialmente passi attraverso il programma usando il debugger, entrando in ciascuna funzione per vedere come funziona e così via. Questo ovviamente non è possibile con sistemi molto grandi, ma 20k LOC non è poi così tanti. :)

Collabora con un altro programmatore che abbia maggiore familiarità con il sistema per sviluppare una nuova funzionalità o correggere un bug. Questo è il metodo che ho visto funzionare meglio.

Penso che tu debba legarlo a un compito particolare. Quando hai tempo a disposizione, scegli il metodo che preferisci.

Quando hai qualcosa che deve essere fatto, concentrati attentamente e fallo.

Chiedi al team di metterti nella correzione dei bug per due settimane (se hai due settimane). Saranno felici di convincere qualcuno a prendersi la responsabilità di questo, e alla fine del periodo avrai passato così tanto tempo a risolvere i problemi con la biblioteca che probabilmente lo saprai abbastanza bene.

Se ha dei test unitari (scommetto che non lo fa). Inizia in piccolo e assicurati che i test unitari non falliscano. Se fissi l'intera base di codice contemporaneamente i tuoi occhi si veleranno e ti sentirai sopraffatto.

Se non ci sono test unitari, è necessario concentrarsi sulla funzione desiderata. Esegui l'app e osserva i risultati delle cose che la tua funzionalità dovrebbe avere. Quindi inizia a cercare il codice cercando di capire come l'app crea le cose che vuoi cambiare. Infine, modificalo e verifica che i risultati vengano visualizzati nel modo desiderato.

Hai menzionato che è un'app e una libreria. Innanzitutto cambia l'app e continua a utilizzare la libreria come utente. Quindi, dopo aver appreso la libreria, sarà più facile cambiare.

Da un approccio dall'alto verso il basso, l'app ha probabilmente un ciclo principale o una GUI principale che controlla tutta l'azione. Vale la pena comprendere il flusso di controllo principale dell'applicazione. Vale la pena leggere il codice per darti un'ampia panoramica del flusso principale dell'app. Se si tratta di un'app GUI, crea un documento che mostra quali schermate sono presenti e come passare da una schermata all'altra. Se si tratta di un'app da riga di comando, come viene eseguita l'elaborazione.

Anche nelle aziende non è insolito avere questo approccio. Spesso nessuno capisce come funziona un'applicazione. E le persone non hanno tempo di mostrarti in giro. Preferiscono domande specifiche su cose specifiche, quindi devi scavare e sperimentare da solo. Quindi, una volta che hai ricevuto la tua domanda specifica, puoi provare a isolare la fonte di conoscenza per quella parte dell'applicazione e chiederla.

Inizia a comprendere il "dominio problematico" (è un sistema di gestione stipendi? inventario? controllo in tempo reale o altro). Se non capisci il gergo utilizzato dagli utenti, non capirai mai il codice.

Quindi guarda il modello a oggetti; potrebbe esserci già un diagramma o potrebbe essere necessario decodificarne uno (manualmente o utilizzando uno strumento come suggerito da Doug). A questo punto potresti anche indagare sul database (se presente), se dovrebbe seguire il modello a oggetti ma potrebbe non farlo, ed è importante saperlo.

Dai un'occhiata alla cronologia delle modifiche o al database dei bug, se c'è un'area che si presenta molto, controlla prima quel bit. Questo non significa che sia scritto male, ma che è il bit che tutti usano.

Infine, mantieni alcune note (preferisco un wiki).

I ragazzi esistenti possono usarlo per assennare i tuoi presupposti e aiutarti.
Dovrai farvi riferimento più tardi.
Il prossimo ragazzo della squadra ti ringrazierà davvero.

Ho avuto una situazione simile. Direi che vai così:

Se si tratta di un'applicazione basata su database, iniziare dal database e provare a dare un senso a ciascuna tabella, ai suoi campi e quindi alla sua relazione con le altre tabelle.
Una volta terminato con il negozio sottostante, passa al livello ORM. Quella tabella deve avere un qualche tipo di rappresentazione nel codice.
Fatto ciò, passa a come e da dove provengono questi oggetti. Interfaccia? quale interfaccia? Qualche validazione? Quale preelaborazione avviene su di loro prima che vadano nell'archivio dati?

Questo ti familiarizzerà meglio con il sistema. Ricorda che provare a scrivere o comprendere unit test è possibile solo quando conosci molto bene cosa è in fase di test e perché deve essere testato in solo in questo modo.

E nel caso di un'applicazione di grandi dimensioni che non è orientata verso i database, consiglierei un altro approccio:

Qual è l'obiettivo principale del sistema?
Quali sono i principali componenti del sistema per risolvere questo problema?
Quali interazioni ha ciascuno dei componenti tra loro? Crea un grafico che rappresenti le dipendenze dei componenti. Chiedi a qualcuno che ci sta già lavorando. Questi componenti devono scambiarsi qualcosa l'uno con l'altro, quindi prova a capire anche quelli (come IO potrebbe restituire l'oggetto File alla GUI e simili)
Una volta che ti senti a tuo agio, tuffati nel componente che dipende meno tra gli altri. Ora studia come quel componente è ulteriormente suddiviso in classi e come interagiscono tra loro. In questo modo hai il blocco di un singolo componente in totale
Passa al componente meno dipendente successivo
Alla fine, passa al componente principale che in genere avrebbe dipendenze da molti degli altri componenti che hai già affrontato
Mentre guardi il componente principale, potresti riferirti ai componenti che hai esaminato in precedenza, quindi non preoccuparti, continua a lavorare sodo!

Per la prima strategia: Prendiamo ad esempio l'esempio di questo sito stackoverflow. Esamina il datastore, cosa viene archiviato, come viene archiviato, quali rappresentazioni hanno quegli elementi nel codice, come e dove vengono presentati nell'interfaccia utente. Da dove vengono e quale elaborazione avviene su di loro una volta che tornano all'archivio dati.

Per il secondo Prendi ad esempio un elaboratore di testi. Quali componenti ci sono? IO, UI, Pagina e simili. In che modo interagiscono tra loro? Procedi man mano che impari ulteriormente.

Rilassati. Il codice scritto è la mentalità di qualcuno, la logica congelata e lo stile di pensiero e ci vorrebbe tempo per leggere quella mente.

In primo luogo, se hai membri del team disponibili che hanno esperienza con il codice, dovresti organizzare che facciano una panoramica del codice con te. Ogni membro del team dovrebbe fornire informazioni sulla propria area di competenza. Di solito è utile convincere più persone a spiegare le cose, perché alcune saranno più brave a spiegare di altre e altre avranno una comprensione migliore di altre.

Quindi, devi iniziare a leggere il codice per un po 'senza alcuna pressione (un paio di giorni o una settimana se il tuo capo lo fornirà). Spesso aiuta a compilare / costruire il progetto da soli ed essere in grado di eseguire il progetto in modalità debug in modo da poter scorrere il codice. Quindi, inizia a bagnare i piedi, correggendo piccoli bug e apportando piccoli miglioramenti. Spero che presto sarai pronto per un progetto di medie dimensioni e, successivamente, per un grande progetto. Continua ad appoggiarti ai tuoi compagni di squadra mentre vai, spesso puoi trovarne uno in particolare che è disposto a fare da mentore a te.

Non essere troppo duro con te stesso se fai fatica - è normale. Può richiedere molto tempo, forse anni, per comprendere una base di codice di grandi dimensioni. In realtà, spesso accade che anche dopo anni ci siano ancora alcune parti del codice che sono ancora un po 'spaventose e opache. Quando hai tempi di inattività tra i progetti puoi scavare in quelle aree e spesso scoprirai che dopo alcuni tentativi puoi capire anche quelle parti.

Buona fortuna!

Potresti prendere in considerazione la possibilità di esaminare gli strumenti reverse engineering del codice sorgente . Ci sono due strumenti che conosco:

Kit SWAG (solo Linux) link
Bauhaus accademico commerciale

Entrambi gli strumenti offrono set di funzionalità simili che includono analisi statiche che producono grafici delle relazioni tra i moduli nel software.

Ciò è principalmente costituito da grafici delle chiamate e decenze di tipo / classe. La visualizzazione di queste informazioni dovrebbe darti una buona idea di come le parti del codice si collegano tra loro. Usando queste informazioni, puoi scavare nella fonte effettiva per le parti che ti interessano di più e che devi prima capire / modificare.

Trovo che saltare al codice possa essere un po 'travolgente. Prova a leggere quanta più documentazione possibile sul progetto. Si spera che questo spieghi lo scopo e la struttura di ciascun componente. È meglio se uno sviluppatore esistente può guidarti attraverso questo, ma ciò non è sempre possibile.

Quando ti senti a tuo agio con la struttura di alto livello del codice, prova a correggere uno o due bug. questo ti aiuterà a familiarizzare con il codice attuale.

Mi piacciono tutte le risposte che dicono che dovresti usare uno strumento come Doxygen per ottenere un diagramma di classe, e prima provare a capire il quadro generale. Sono totalmente d'accordo con questo.

Detto questo, ciò dipende in gran parte da quanto bene il codice deve essere preso in considerazione. Se è un casino gigantesco, sarà difficile da imparare. Se è pulito e organizzato correttamente, non dovrebbe essere così male.

Vedi questa risposta su come utilizzare gli strumenti di copertura dei test per individuare il codice per una funzione di interesse, senza sapere nulla su dove si trova tale funzionalità o su come viene distribuito su molti moduli.

(marketing senza vergogna)

Dovresti dare un'occhiata a nWire . È un plug-in Eclipse per la navigazione e la visualizzazione di basi di codice di grandi dimensioni. Molti dei nostri clienti lo usano per irrompere nuovi sviluppatori stampando visualizzazioni dei principali flussi.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow