Quanti sviluppatori prima dell'integrazione continua diventano efficaci per noi?


34

Esiste un sovraccarico associato all'integrazione continua, ad es. Impostazione, riqualificazione, attività di sensibilizzazione, interruzione per correggere "bug" che si rivelano essere problemi di dati, separazione forzata degli stili di programmazione delle preoccupazioni, ecc.

A che punto l'integrazione continua si ripaga da sola?

EDIT: questi erano i miei risultati

L'allestimento è stato CruiseControl.Net con Nant, lettura da VSS o TFS.

Ecco alcuni motivi di errore, che non hanno nulla a che fare con l'installazione:

Costo dell'indagine : il tempo impiegato per verificare se una luce rossa è dovuta a un'incongruenza logica reale nel codice, nella qualità dei dati o in un'altra fonte come un problema di infrastruttura (ad esempio un problema di rete, una lettura del timeout dal controllo della fonte, server di terze parti è inattivo, ecc. ecc.)

Costi politici sull'infrastruttura : ho considerato di eseguire un controllo "infrastruttura" per ciascun metodo nell'esecuzione del test. Non avevo soluzione al timeout se non per sostituire il server di build. La burocrazia si è messa in mezzo e non è stato possibile sostituire il server.

Costo del fissaggio dei test unitari : una luce rossa a causa di un problema di qualità dei dati potrebbe essere un indicatore di un test unitario scritto male. Pertanto, i test unitari dipendenti dai dati sono stati riscritti per ridurre la probabilità di una luce rossa a causa di dati errati. In molti casi, i dati necessari sono stati inseriti nell'ambiente di test per poter eseguire accuratamente i test unitari. Ha senso affermare che rendendo i dati più affidabili, il test diventa più robusto se dipende da questi dati. Certo, ha funzionato bene!

Costo della copertura, ovvero scrivere test unitari per codice già esistente : si è verificato il problema della copertura unit test. C'erano migliaia di metodi che non avevano test unitari. Quindi, sarebbe necessaria una considerevole quantità di giornate uomo per crearle. Dato che sarebbe stato troppo difficile fornire un caso aziendale, è stato deciso che i test unitari sarebbero stati utilizzati per qualsiasi nuovo metodo pubblico in futuro. Quelli che non avevano un test unitario erano definiti "potenzialmente a infrarossi". Un punto interessante qui è che i metodi statici erano un punto controverso nel modo in cui sarebbe stato possibile determinare in modo univoco come un metodo statico specifico aveva fallito.

Costo delle versioni su misura : gli script Nant vanno solo fino ad ora. Non sono così utili per, diciamo, build CMS dipendenti per EPiServer, CMS o qualsiasi distribuzione di database orientata all'interfaccia utente.

Questi sono i tipi di problemi che si sono verificati sul server di build per esecuzioni orarie di test e build di QA durante la notte. Sono lieto che questi non siano necessari in quanto un build build può eseguire queste attività manualmente al momento del rilascio, in particolare, con una banda di un uomo e una build piccola. Quindi, le build a singolo passaggio non hanno giustificato l'uso della CI nella mia esperienza. Che dire delle build più complesse a più fasi? Questi possono essere dolorosi da costruire, soprattutto senza una sceneggiatura di Nant. Quindi, anche dopo averne creato uno, questi non hanno avuto più successo. I costi per risolvere i problemi di luce rossa hanno superato i benefici. Alla fine, gli sviluppatori hanno perso interesse e hanno messo in dubbio la validità della luce rossa.

Dopo averlo provato, credo che la CI sia costosa e che ci sia molto da lavorare sui bordi invece di portare a termine il lavoro. È più conveniente impiegare sviluppatori esperti che non creano problemi con grandi progetti piuttosto che introdurre e mantenere un sistema di allarme.

Questo è il caso anche se quegli sviluppatori se ne vanno. Non importa se un buon sviluppatore se ne va perché i processi che segue assicurano che scriva le specifiche dei requisiti, le specifiche di progettazione, si attiene alle linee guida di codifica e commenta il suo codice in modo che sia leggibile. Tutto questo è stato rivisto. Se ciò non accade, il suo caposquadra non sta facendo il suo lavoro, che dovrebbe essere raccolto dal suo manager e così via.

Perché CI funzioni, non è sufficiente scrivere unit test, tentare di mantenere la copertura completa e garantire un'infrastruttura funzionante per sistemi di dimensioni considerevoli.

La linea di fondo: ci si potrebbe chiedere se la correzione di tanti bug prima del rilascio sia desiderabile anche da una prospettiva aziendale. CI richiede molto lavoro per acquisire una manciata di bug che il cliente potrebbe identificare in UAT o che la società potrebbe essere pagata per la riparazione come parte di un contratto di servizio alla scadenza del periodo di garanzia.


13
Può essere utile anche per una squadra di uno. Soprattutto se si dispone di una suite di test di lunga durata, è molto meglio ottenere automaticamente risultati di una build e di un test notturni piuttosto che farlo manualmente tutto il tempo.
SK-logic

3
@Carnotaurus, il clone locale del repository git remoto elimina il timeout dal controllo del codice sorgente. Problemi di rete: per la creazione del prodotto? Ora, davvero ...

3
La luce rossa di @Carnotaurus a causa della qualità dei dati o dell'infrastruttura è un codice dei test fragili . Vedi anche così: la gestione-la-manutenzione-carico-of-unità di test
K3b

1
Più un test dipende da aspetti esterni, più è fragile. Esempio: se un test ha esito positivo solo se il cliente XY è nel database, il test è fragile a meno che l'installazione del test non garantisca l'esistenza di questo prerequisito inserendo i dati stessi se necessario.
k3b,

6
"In conclusione: perché realizzare prodotti funzionanti quando possiamo convincere qualcun altro a pagarci per risolverlo, perché non è come se si aspettassero che il software funzionasse in primo luogo"? Potrebbe non soddisfare la definizione legale, ma a me sembra una frode.
Chris Pitman,

Risposte:


43

L'impostazione di un motore CI è simile all'impostazione di un allarme antincendio in una casa.

Nella mia mente i vantaggi non sono correlati con molti sviluppatori, ma con una base di codice di grandi dimensioni. Il motore CI fa attivamente tutto il lavoro noioso che non vuoi fare tu stesso e lo fa ogni volta.

Se rompi un modulo remoto che non tocchi da molto tempo, ti viene immediatamente comunicato. Non solo compilazione saggia, ma anche funzionalmente se hai impostato i test unitari.

Inoltre, se lasci che il tuo motore CI faccia tutto il lavoro noioso, inclusa la configurazione di programmi di installazione, ecc., Non devi farlo manualmente. Puoi semplicemente controllare la tua fonte e attendere che il prodotto finito venga costruito nella posizione standard. (EDIT: il motore CI funziona anche in un ambiente ben definito, evitando qualsiasi configurazione specifica dello sviluppatore, garantendo la riproducibilità)

Anche questo fa parte dell'assicurazione della qualità.


EDIT: Dopo aver scritto quanto sopra, ho avuto esperienza con lo strumento di costruzione Maven per Java. In sostanza, questo ci consente di mantenere la configurazione CI completa all'interno del progetto (con pom.xml), rendendo molto più semplice la manutenzione dell'installazione CI e / o la migrazione a un altro motore CI.


1
@Carnotaurus, in tal caso la luce rossa viene utilizzata anche per errori transitori. Sembra una limitazione nel motore CI che stai utilizzando.

2
@Carnotaurus, nella mia esperienza, il lavoro svolto per documentare accuratamente ogni aspetto di tutto ciò che riguarda, ad esempio, fare una versione e poi fare una serie di volte, è più grande che catturare il flusso di lavoro in uno script di formica o maven che può quindi essere eseguito da un robot qualsiasi numero di volte. Detto robot funziona anche in un ambiente pulito, garantendo la riproducibilità delle build.

1
Nota che la rottura che sto cercando non sta fallendo i test unitari, ma che i programmi attuali che spediamo possono ancora costruire. Non è più così importante come abbiamo migrato verso manufatti maven invece di compilare tutto per ogni versione, ma è comunque importante sapere che la build è completamente funzionale. Abbiamo solo bisogno della parte di implementazione continua.

2
@Carnotaurus: non sto parlando di un sistema di allarme. Se i test falliscono, la patch non è integrata nel repository principale (affatto), assicurando che ogni volta che si esegue il checkout / clone si ottiene una copia completamente funzionante e si può iniziare a lavorare immediatamente. Ora, sono d'accordo con te sul fatto che i test possono essere difficili da scrivere e mantenere ... ma ho lavorato con e senza test e vedo un netto miglioramento della qualità con loro. Quindi la domanda è: automatizzata o no? Nella mia esperienza, ci vuole più tempo per testare manualmente che per scrivere lo script di automazione (ma lavoro in una grande azienda con strumenti per quello).
Matthieu M.

5
" È un sacco di lavoro per catturare una manciata di bug che la società verrebbe comunque pagata per la riparazione come parte di un contratto di servizio al cliente " - beh in quel caso hai incentivo economico a NON produrre software con il minor numero di bug possibile, e in tal caso tutto ciò non si applica a te.

33

Non è quanti sviluppatori, ma quanti passi ci vogliono per passare da 1 a n (incluso), dove 1 & n sono ...

1: Verifica del codice
E
: avere pacchetti installabili \ distribuibili

Se n <2 forse non hai bisogno di CI
altrimenti, hai bisogno di CI

Aggiornamento
Dalla lettura dei risultati, posso solo concludere che ti sei avvicinato alla CI dalla direzione sbagliata e per le ragioni sbagliate.


1
+1 - Ho un sacco di cose che potrei aggiungere a quanto sopra - ma questo è molto vicino al nocciolo del perché mi piace CI ... non solo per quello che fa ma anche per quello che ti richiede di farlo per farlo funziona (quei requisiti sono cose che dovresti fare comunque).
Murph

2
@murph: Sì, e porta piccoli vantaggi come 1) sapere cosa costruirà nel tuo repository, 2) build con un solo clic, 3) essere in grado di rilasciare una versione in un attimo e molto altro ancora
Binary Worrier

Quindi è giusto dire che dipende dalla complessità di ciò che deve essere rilasciato, misurato dal suo numero di passaggi per la distribuzione in quanto in grado di "testare" livelli separati?
Carney,

1
@Carnotaurus: scusa amico, ma non sono sicuro di sapere cosa stai cercando di dire. CI non ha nulla a che fare con i test. Sì, puoi - e dovresti - eseguire unit test come parte della build, ma non dovrebbero dipendere da tutto ciò che non è configurato come parte del test. Tuttavia, la CI aiuta i test. Uno dei tanti vantaggi di CI è che consente a un team addetto al controllo qualità di raccogliere immediatamente e apparentemente nuove modifiche al codice. CI = La possibilità di rilasciare immediatamente
Binary Worrier

1
@BinaryWorrier - Penso che il passaggio 1 stia controllando il codice;)

10

Può valere la pena anche per una squadra di uno. Ciò è particolarmente vero quando si sviluppa codice multipiattaforma ed è necessario assicurarsi che le modifiche funzionino su entrambe le piattaforme. Ad esempio, il compilatore C ++ di Microsoft è più accettabile di GCC, quindi se sviluppi in Windows ma devi supportare anche Linux, avere un sistema CI che ti dica quando le tue interruzioni di build su Linux sono di grande aiuto.

Alcuni sistemi di CI sono abbastanza facili da configurare, quindi il sovraccarico non è poi così grande. Prova Jenkins o Hudson per esempio.


Non avevo considerato uno scenario multipiattaforma. Se sono necessari compilatori diversi per creare build diverse, esiste un caso valido per CI: prendere un voto.
Carney,

4

Come dici tu, c'è un costo generale per configurarlo e mantenerlo in funzione.

Ma la domanda su dove sia il punto di pareggio non è una funzione di quante persone hai nel tuo team, ma piuttosto una funzione della lunghezza del tuo progetto.

Detto questo, c'è una parte del costo di installazione che puoi utilizzare in tutti i tuoi progetti futuri, quindi a lungo termine il costo generale potrebbe avvicinarsi allo zero.


Quindi la lunghezza del progetto (dimensione del progetto) è importante per te CI? Ho trovato i falsi allarmi molto costosi.
Carney,

Sì, devi avere il tempo di rimborsare i costi della curva di impostazione e apprendimento. In teoria, nel tempo dovresti imparare come eliminare i falsi allarmi.
Stephen Bailey,

Sì, questa è teoria
Carney

Bene, no, la sua pratica. Nel tempo, prendi nota di quali test sono fragili e quali non lo sono e non ti preoccupi troppo se i tuoi fragili test si interrompono a meno che non si interrompano più volte di seguito. Scrivi test più isolati e solidi mentre impari e lasci che la copertura legacy si sviluppi nel tempo invece di fare tutto in una volta. In pratica, CI non è un proiettile d'argento, è un cambiamento di processo che richiede tempo e alla fine porta a un software meno difettoso.
philosodad,

3

Questa settimana ho creato Jenkins per creare un piccolo progetto .NET a cui sto lavorando. L'ho integrato con il mio controllo del codice sorgente Git in modo da innescare un build su ogni commit. Ho integrato i test unitari nella build. Ho integrato l'analisi statica sotto forma di violazioni di FxCop e StyleCop.

Ora ogni volta che eseguo il check-out, controlla tutto il mio codice, lo crea, incrementa il numero di versione in tutti gli assembly, lo verifica, lo analizza per le violazioni di FxCop e StyleCop, archivia la build e registra i risultati in un numero di grafici, quindi Ho visibilità nel tempo dei risultati dei test e delle violazioni.

Farlo da zero richiede circa un'ora (forse un giorno con Google se non l'hai mai fatto prima). Non costa nulla perché tutti gli strumenti sono disponibili gratuitamente.

Se, come e quando il progetto sarà realizzato, ho un'infrastruttura di alta qualità che crescerà con essa gratuitamente. Se o quando i nuovi sviluppatori si uniscono al progetto, posso ottenere visibilità totale sul loro lavoro e il loro impatto sul progetto senza alcun costo.

Quindi l'unico scenario in cui vedo che non vale la pena CI è o per un progetto che richiederà circa un giorno e poi non verrà mai rivisitato, o uno in una lingua in cui non ci sono strumenti disponibili / gratuiti e il costo per acquisirli è sproporzionato rispetto al lavoro.


Come ho detto, sono i test unitari a coprire il codice legacy che presentano un costo maggiore. Inoltre, non stiamo parlando di una squadra di un solo uomo qui ... Apprezzo però il testa a testa su Jenkins.
Carney,

1
Per quello che vale, ho ottenuto notevoli vantaggi dall'esecuzione di un server CI senza test - solo dalla fiducia in build pulite e dalla disponibilità di pacchetti di distribuzione.
Murph,

1

Se riesci a verificare tutti gli aspetti del tuo progetto dopo ogni modifica, non hai bisogno di elementi della configurazione.

In tutti gli altri casi, è una vittoria netta.


Penso che sia anche da qui che vengo. È anche molto più economico.
Carney,

Cosa intendi per verifica in questo caso? Se è automatizzato, accade il più frequentemente possibile e aiuta a identificare i disturbi mentali e le sviste, allora sono tutto per questo. :-)
William Payne,

1

Il sovraccarico è minimo. Direi che per i progetti di un uomo sarebbe utile. Una volta raggiunti due è inestimabile.

Concordo sul fatto che per i progetti one man se si dispone di un "build / verifica in un solo passaggio", allora si potrebbe andare bene con l'integrazione continua, ma in quei casi hai fatto la maggior parte del duro lavoro per impostare CI, quindi potrebbe anche in un sistema formale (CC, Hudson, TeamCity, ecc.).


Intendi senza CI?
Carney,

1

La domanda su, quando si paga per se stesso, è difficile rispondere a un nuovo progetto.

Su un progetto esistente, è molto più facile da vedere. Se trovi un bug critico nella parte di sviluppo della catena di approvvigionamento, sai che il problema esiste al più presto possibile. Il costo per la correzione è ora il più basso. Se il problema esiste in qualsiasi ambiente al di sopra dello sviluppo, il costo è più elevato.

Ora, la direzione potrebbe decidere di rilasciare un bug, ma questo è un rischio aziendale. Almeno ora può essere mitigato attraverso quella valutazione del rischio, piuttosto che telefonate / panici a tarda notte, che, se fatturati a tariffe orarie, finiscono per essere molto costosi.

Un'altra cosa da considerare in termini di costi. Com'è il tuo dipartimento di controllo qualità? Si tratta di test manuali? Se vai in CI, potresti essere in grado di ridurre i costi complessivi di QA automatizzando quegli script sulla tua casella di sviluppo. Potresti essere in grado di ridurre il numero di addetti al controllo qualità che supportano il tuo progetto coinvolgendoli nella fase CI.


1
Per sostituire un test di regressione manuale con alcuni test automatici dell'interfaccia utente sono necessari un po 'di tempo e abilità. In una società, un tipo ha scritto circa il 40% dei test e ha lasciato l'azienda. Diversi anni dopo, i test non sono ancora stati scritti. Scommetto che è tipico.
Carney,

No, non è tipico.
quant_dev,

Non ho visto molte contro prove
CarneyCode il

Se scrivi test di integrazione / accettazione in DSL in linguaggio naturale come Gherkin, puoi facilmente tradurre il test automatizzato in manuale. Quindi non lo vedo come un problema.
Mike Cornell,

@Carnotaurus - Penso che sia tipico. L'ho visto anche due volte. I test automatici dell'interfaccia utente sono difficili.
Rocklan,

1

L'IC è sempre sempre valsa la pena: il senso di sicurezza che ti dà ti consente di lavorare a un ritmo più veloce di quanto sarebbe possibile altrimenti. Il problema che hai sembra ruotare attorno ai test unitari. Concordo sul fatto che i test unitari sono molto costosi, ma penso anche che (per molte cose) siano l'opzione peggiore che abbiamo. Personalmente, e per i tipi di sistemi su cui tendo a lavorare, lo giuro con test a livello di sistema operanti su una combinazione di casi patologici del mondo reale e (possibilmente sintetici); È più economico dei test unitari ed entra in quegli angoli difficili da raggiungere del tuo universo concettuale: gli "Unknown Unknowns" di Donald Rumsfeld.


Mi piace il bit sui test dell'interfaccia utente a livello di sistema. Gran parte dei test si perde in una nebbia di test unitari di qualità e copertura discutibili.
Carney,

La copertura è anche una questione di psicologia umana; abbiamo una tendenza innata a scrivere test per quei casi a cui abbiamo già pensato. È per questo motivo che per essere certificati ad un livello SIL elevato, i test unitari devono essere scritti da un team separato da quello che ha sviluppato il sistema in prova, e anche allora ci sono molti casi e situazioni che sono ovvi solo per tutti ripensandoci. È necessario un controllo rigoroso della copertura del codice; ma straordinariamente difficile e costoso.
William Payne,

... Da qui il vantaggio che ottieni lanciando la spazzatura più cattiva che puoi trovare nel sistema al livello più alto e vedendo cosa succede ... :-)
William Payne,

1
+1 - Totalmente d'accordo. Alcune parti di un sistema non sono semplicemente testabili in unità (ovvero i bordi come nel database). Sicuramente puoi deridere il db, ma questo lascia il codice che parla al db non testato. Ad un certo punto devi scrivere alcuni test del mondo reale che integrino i tuoi sistemi e parlino con altri sistemi. Quando lo fai trovi sempre bug che ti sei perso nell'accogliente mondo pulito del test unitario e del framework beffardo (mi viene in mente LINQ to SQL).

In realtà, recentemente ho scoperto un'interessante interpretazione dei
William Payne,

0

Usalo sempre, indipendentemente dalle dimensioni della squadra. Se ad esempio sei solo tu, chissà, potresti scrivere codice dal tuo laptop su Starbucks, quindi continuare dal tuo sistema più robusto a casa?

Il sovraccarico non è poi così male.


0

Uno. Sì, uno è sufficiente per iniziare a utilizzare l'integrazione continua.


0

Non si tratta di quanti sviluppatori, ma di

un. Quanto tempo risparmi utilizzando l'automazione e quanto spesso.

  • Tempo risparmiato sulla costruzione dopo integrazioni, esecuzione di test automatizzati e creazione di impostazioni * frequenza del check-in = percentuale di tempo risparmiata.

b. Quante versioni / filiali / prodotti hai.

  • Se si dispone di uno sviluppatore che lavora su due rami diversi, il tempo risparmiato viene raddoppiato, poiché ogni ramo richiederebbe la costruzione, il collaudo e l'imballaggio.
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.