Come organizzi le cartelle dei tuoi progetti? [chiuso]


15

Buon pomeriggio

Vorrei sapere come organizzate le vostre cartelle di progetto?

Una volta avevo un capo che mi suggeriva di organizzare per i clienti.

Projects
|
|----Customer 1
     |---- A Cool Solution 1
           |---- source
                 |---- version1.0
                 |---- version1.1
           |---- docs
                 |---- analysis
                 |---- meetings
                 |---- manuals
|----Customer 2
|----Customer 3

Un mio amico mi ha detto di organizzare tem by Technology

Projects
|
|----.NET
     |---- C#
          |---- Customer 1     
                |---- A Cool Solution 1
                      |---- source
                            |---- version1.0
                            |---- version1.1
                      |---- docs
                            |---- analysis
                            |---- meetings
                            |---- manuals
|----Ruby
|----PHP

E tu? Hai un modo intelligente per organizzare le cartelle del tuo progetto?


# 2 è meglio ...
Yousha Aleayoub,

Ciao, 2018 qui. Cosa hai scelto?
Danyal Aytekin,

Risposte:


6

Questo è quello che abbiamo usato:

Projects
|
|----Customer A
     |---- Project 1
     |     |---- BuildControl       (CI/nAnt/Make/MSBuild files and config, etc)
     |     |---- Documentation      (In XML format so we can 'build' them)
     |     |---- Source
     |     |     |---- Component X
     |     |     |---- Component X.tests
     |     |     |---- Component Y 
     |     |     |---- Component Y.tests
     |     |---- Testing
     |     Project 1.sln      (Has folders as per project on-disk structure)
     |---- Project 2
     |---- Shared/Common components
|----Customer B
|----Customer C
|----<Our Company>
     |---- Internal Project A
     |---- Internal Library B

Usiamo questa struttura per più progetti con molti clienti diversi ormai da anni e funziona molto bene.

È molto simile al tuo suggerimento iniziale, ma usiamo il controllo della versione per gestire il controllo delle versioni. I repository del server sono denominati "Cliente X - Progetto Y", piuttosto che altro. Questo ci consente di avere appaltatori esterni che lavorano su alcuni progetti ma non sono in grado di accedere ad altri in quanto possiamo impostare le autorizzazioni nella radice del controllo versione.

Ognuno controlla le proprie copie di lavoro dove vuole sulla propria macchina di sviluppo (Windows) e utilizza il comando SUBST per mappare una lettera di unità in quella posizione. In questo modo possiamo avere percorsi relativi codificati nei file di build, ecc., Che funzionano attraverso l'installazione di tutti. Quindi, ad esempio, possiamo avere collegamenti a librerie condivise, se lo desideriamo. Di solito usiamo collegamenti / alias di controllo versione per raggiungere questo obiettivo.

Un grande vantaggio di questa struttura è che puoi isolare il codice dei clienti l'uno dall'altro. Ciò è utile se è necessario (a) inviare loro aggiornamenti regolari della fonte a fini di integrazione, (b) avere appaltatori esterni che lavorano su parti selezionate del codice.

Il tuo secondo suggerimento non funzionerà così bene con un progetto complesso che utilizza più di una tecnologia.


Abbastanza ragionevole, ma -1 per richiedere percorsi assoluti codificati. I percorsi relativi hardcoded dovrebbero funzionare per il 99,9% delle cose.
Wyatt Barnett,

1
Ehm, ho messo percorsi assoluti lì?
JBR Wilkinson,

8

Sono piuttosto piatto:

/ Progetti

Alcune varianti arrivano a seconda della casella, ma dietro ci sono solo molte cartelle individuali per i progetti. Il vero affare vive comunque nel controllo del codice sorgente, quindi questa è solo la casa temporanea locale.


3

Ho una struttura che assomiglia vagamente al seguente:

~/
|-- Developer/
|   |-- Projects/
|   |   |-- Archives/
|   |   |-- Current/
|   |   |-- Work/
|-- Projects -> ~/Developer/Projects/Current

Archivescontiene vecchi progetti a cui non sto più lavorando. Workcontiene progetti relativi al lavoro. Currentè tutto lo sviluppo attuale. Quindi, nella mia directory home, mi collego Projectsa ~/Developer/Projects/Current. ~/Projectsinclude anche collegamenti simbolici ad alcuni progetti di lavoro.


Lo spostamento di progetti da Current to Work a Archive non va bene con l'utilizzo degli strumenti di controllo della versione di origine. In questo caso è meglio avere riferimenti / collegamenti alle cartelle (al di fuori della copia di lavoro). Forse stai spostando copie di lavoro all'interno di "archivi", "corrente" e "lavoro"?
Fil

1
@Fil: io uso Git. Ogni progetto è un repository autonomo, quindi non importa dove viene spostato.
mipadi,

3

Ho anche una struttura piatta.

/ Progetti

D'accordo con Wyatt Barnett, il vero affare vive comunque nel controllo del codice sorgente.

Voglio solo aggiungere che non dovrebbe esserci nulla di speciale nella struttura delle cartelle, poiché molti IDE forniscono comunque collegamenti a progetti / file recenti. E su quanti progetti lavora qualcuno? Davvero, solo per definizione, quelli recenti.

Inoltre, aggiungo comunque solo i progetti recenti nella cartella di livello superiore. Archivo tutte le cose più vecchie e completate in:

/ Progetti / Old_stuff

o qualcosa di simile. Archivo ciò su cui generalmente non lavorerò più.


Saresti sorpreso - in genere ho bisogno di una dozzina di progetti collegati, attuali e pronti per essere eseguiti sul mio laptop "go" e posso facilmente aprirne una mezza dozzina nel corso di una giornata normale.
Wyatt Barnett,

3

In passato ho usato i repository Subversion per archiviare i miei documenti di origine e ho seguito la convenzione "project-minor" per l'organizzazione dei repository, che ho trovato molto efficace sia per le organizzazioni grandi che per quelle piccole.

Vorremmo strutturare i nostri rami del repository; tag e trunk come segue:

branches-+
         +-personal-+
         |          +-alice-+
         |          |       +-shinyNewFeature
         |          |       +-AUTOMATED-+
         |          |                   +-shinyNewFeature
         |          +-bob-+
         |                +-AUTOMATED-+
         |                            +-bespokeCustomerProject
         +-project-+
                   +-shinyNewFeature
                   +-fixStinkyBug
tags-+
     +-m20110401_releaseCandidate_0_1
     +-m20110505_release_0_1
     +-m20110602_milestone
trunk

All'interno dello stesso albero dei sorgenti, useremmo (qualcosa di simile) la seguente struttura:

  (src)-+
        +-developmentAutomation-+
        |                       +-testAutomation
        |                       +-deploymentAutomation
        |                       +-docGeneration
        |                       +-staticAnalysis
        |                       +-systemTest
        |                       +-performanceMeasurement
        |                       +-configurationManagement
        |                       +-utilities
        +-libraries-+
        |           +-log-+
        |           |     +-build
        |           |     +-doc
        |           |     +-test
        |           +-statistics-+
        |           |            +-build
        |           |            +-doc
        |           |            +-test
        |           +-charting-+
        |           |          +-build
        |           |          +-doc
        |           |          +-test
        |           +-distributedComputing-+
        |           |                      +-build
        |           |                      +-doc
        |           |                      +-test
        |           +-widgets-+
        |                     +-build
        |                     +-doc
        |                     +-test
        +-productLines-+
        |              +-flagshipProduct-+
        |              |                 +-coolFeature
        |              |                 +-anotherCoolFeature
        |              |                 +-build
        |              |                 +-doc
        |              |                 +-test
        |              +-coolNewProduct-+
        |                               +-build
        |                               +-doc
        |                               +-test
        +-project-+
                  +-bigImportantCustomer-+
                  |                      +-bespokeProjectOne
                  |                      +-bespokeProjectTwo
                  +-anotherImportantCustomer-+
                                             +-anotherBespokeProject

L'idea era (ed è tuttora) di utilizzare la struttura del repository per aiutare a strutturare la comunicazione tra il team di ingegneri; la parte del business rivolta al cliente e varie altre parti interessate ed esperti di dominio.

In altre parole: i documenti di origine che si trovano in una delle directory del "progetto" vengono utilizzati (e guadagnano) una sola volta. I documenti che si trovano in una delle directory "productLines" guadagnano denaro quante volte viene venduto un prodotto di quella particolare linea. I documenti che si trovano in una delle directory delle "biblioteche" guadagnano denaro tutte le volte che viene venduto qualsiasi prodotto che li utilizza.

Rende esplicita la nozione di ammortamento dei costi e aiuta a costruire il supporto per il riutilizzo dei documenti di origine in tutta l'azienda.

In un mondo ideale, il cliente che affronta una parte del business userebbe anche questa struttura per archiviare presentazioni e altre garanzie di vendita, in modo che gli sviluppatori possano vedere quali aspettative dei clienti sono state create, accanto alla relativa directory dei prodotti, e i colleghi rivolti ai clienti possono monitorare lo sviluppo progressi sulle funzionalità e sui prodotti che stanno vendendo.

Significa anche che esiste una struttura comune su cui possono operare i nostri strumenti di automazione della costruzione. (I nostri script di compilazione percorrono l'albero dei sorgenti alla ricerca di cartelle "build" all'interno delle quali trovano i file di configurazione che specificano come costruire ciascun componente; un processo simile si verifica per la generazione e il collaudo della documentazione). Ancora una volta, in un mondo ideale, il sito Web dell'organizzazione e altre garanzie di marketing potrebbero essere costruite allo stesso modo.

Come ultima nota; il sistema di integrazione continua sa che deve innescare una build; analisi statica; test del fumo e test dell'unità vengono eseguiti ogni volta che viene modificato il tronco, ogni volta che viene modificato un ramo "tag" e ogni volta che viene modificato un ramo "AUTOMATICO". In questo modo, i singoli sviluppatori possono utilizzare il sistema CI con i loro rami personali, una capacità importante, IMHO.


0

Penso che tu intenda "cartella documentazione". Organizzo i miei documenti per settore prima di tutto, dopo per cliente / applicazione, alla fine per "sviluppo e manutenzione".

Esempio: progetti

  • Finanziario

    • applicazione web

      • App Alpha

         - source
         - functional docs
         - etc etc (testing, meeting with customer)
        
      • App Beta

         - functional docs
         - etc etc (testing, meeting with customer)
        
    • Software desktop
  • Energia e servizi pubblici
  • BLA BLA

Che dire del controllo versione? Un documento Alpha non diventa un documento Beta man mano che procede?
JBR Wilkinson,

Sul desktop locale non ho tutte le copie di tutta la versione: ho l'ultima versione stabile di codice, documenti, ecc. Se ho bisogno di un'altra versione precedente, scarico questa versione di Subversion et similia (memorizzandola come un altro progetto in il settore: App Beta_version_XYZ se finanziaria)
alepuzio,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.