Test Driven Development e Pair Programming [chiuse]

StackOverflow https://stackoverflow.com/questions/882661

Domanda

Sono in una squadra in cui sto provando a convincere i miei compagni di squadra ad adottare TDD (come ho visto il lavoro nella mia squadra precedente e la configurazione è simile). Inoltre, la mia convinzione personale è che, almeno all'inizio, aiuta davvero se sia TDD e programmazione coppia sono fatti in congiunzione. In questo modo, due inesperti (in TDD) gli sviluppatori possono aiutarsi a vicenda, discutere che tipo di test per scrivere e fare un buon progresso.

Il mio manager, d'altra parte, ritiene che se introduciamo due nuove pratiche di sviluppo nella squadra in una sola volta, c'è una buona probabilità che entrambi potrebbero fallire. Così, vuole essere un po 'più conservatore e introdurre uno qualsiasi.

Come faccio a convincerlo che entrambi sono complementari e non ortogonale. O mi sbaglio?

È stato utile?

Soluzione

Non sono sicuro che avere più persone che non sanno quello che stanno facendo in TDD sta per aiutare. Sarà scendere rapidamente in entrambi Googling del soggetto, o di tutti e due discutendo su esattamente ciò che TDD è / non è.

penso che sarebbe meglio di ottenere qualcuno del team di diventare l'evangelista per una determinata tecnica (qualcuno va e legge sul TDD, qualcuno va e legge sulla programmazione coppia) e hanno queste persone poi promuovere e di prova quelle cose. Sì, entrambi possono accadere allo stesso tempo, ma non c'è bisogno di essere utilizzato in tutto il team di progetto. Si potrebbe avere un piccolo gruppo della tua squadra non associare la programmazione e poi riferire sulle loro esperienze.

Altri suggerimenti

Coppia programmazione è efficace quando si impara una nuova pratica soprattutto TDD

Quindi, si può avere sia con un compromesso. Fate questo in modo agile, in modo incrementale. Prendere sulla programmazione prima coppia. E 'il più facile dei due. Tutte le pratiche dopo la programmazione coppia diventerà molto più facile da imparare e saranno adottati dal team in modo più rapido e con maggiore consistentcy. programmazione coppia è uno dei primi se non il primo pratica engineerring che dovrebbe essere adottato. Assicurarsi che sia fatto in modo efficace. Qui di seguito è una descrizione di come fare pair programming.

programmazione Accoppiato è una delle pratiche più potenti di un team di sviluppo può utilizzare nello sviluppo di software. Abbinamento si verifica con due sviluppatori attivamente lo sviluppo di una scheda di storia utilizzando un singolo computer e la tastiera. I gestori temono che utilizzando la programmazione abbinato raddoppierà i loro costi di programmazione. A prima vista, è comprensibile il motivo per cui si potrebbe pensare che - dopo che tutti i --two sviluppatori sono invitati a lavorare insieme sullo stesso compito. In pratica, però, team Agile utilizzano questa tecnica di sviluppo hanno scoperto che il leggero aumento dei costi di sviluppo iniziale (15% secondo uno studio University of Utah) sono più che compensata da una riduzione dei difetti, un test più breve e meno costoso ciclo e minore necessità di sostegno alla produzione.

Anche se può sembrare un controsenso che avere programmatori Pair e lavorare insieme migliora la produttività, ci sono una serie di motivi per cui questa tecnica funziona davvero Ecco perché (si pensi al vecchio detto, "Due teste sono meglio di uno."):

  • Miglioramento della qualità - Associazione incoraggia la revisione del codice. Molti errori catturati durante la digitazione. Accoppiato programmazione significa la revisione del codice continuo fatto da due persone che si impegnano per la qualità del codice e stanno lavorando insieme per individuare e correggere gli errori in ogni momento. Uno studio condotto dalla University of Utah ha scoperto che il numero finale della difetti riscontrati nel codice è stato ridotto del 15% in media per il codice scritto da coppie.
  • Meno Tempo trascorso "Stuck" - La programmazione è difficile. Spesso gli sviluppatori faticano a trovare una soluzione e trascorrono più tempo di quanto dovrebbero "bloccati". Avere un partner per un brainstorming con e ad accettare di chiedere aiuto, se necessario, riduce la quantità di tempo improduttivo speso bloccato cercando di trovare una soluzione.
  • Meno tempo speso per Distrazioni -. Uno sviluppatore è meno probabile il tempo speso per le chiamate personali di telefono o navigare sul web, e-mail o le vacanze, quando lui o lei sta lavorando con un partner
  • Due prospettive vengono applicate al problema - Differenti livelli di esperienza, diversi stili di problem solving, abilità diverse ausiliari tutte aumentano le probabilità di risolvere un problema più veloce. Lo studio svolto dalla University of Utah ha inoltre individuato una migliore progettazione complessiva e più breve lunghezza del codice per il software scritto da coppie.
  • Meno paura dello sconosciuto - Durante l'associazione con un altro sviluppatore è più facile affrontare un problema o cercare di ottenere una maniglia sulla nuova tecnologia di quanto non lo sia quando lavora da solo. Hanno anche guadagnare, nel corso del tempo, una migliore comprensione dell'intera applicazione. Alla fine, il progetto finisce con più persone comprensione ogni pezzo del sistema a causa di accoppiamento.
  • meno probabilità di costruire in Campo di applicazione - Spesso gli sviluppatori di buon grado di aggiungere funzionalità non affrontate nei requisiti. Quando si lavora con una coppia, il secondo sviluppatore è più probabile che per mantenere la sua / il suo partner sul compito.
  • Migliorata Dynamics squadra - A causa del metodo associato, le persone imparano a lavorare insieme. Parlano più spesso e sperimentare un migliore flusso di informazioni. la dinamica squadra a migliorare di conseguenza. In realtà, abbiamo scoperto che la migliore esperienza di team building intorno sta lavorando insieme per produrre software del tuo cliente è entusiasta. Tutti amano essere parte di un team di successo.
  • Eliminazione di Silos di Knowledge -. conoscenza del dominio, la conoscenza del codice o pratiche sono rapidamente propagate attraverso la coppia di squadra e lo sviluppatore uno con l'altro su una base di rotazione

Una volta che la squadra è confortevole, con l'associazione, poi prendere il TDD. A Destription segue:

Test-Driven Development (TDD) è una pratica di ingegneria di sviluppo del software che consiste di breve scoppio di sviluppo in cui un nuovo banco di prova che copre il miglioramento desiderato o nuova funzionalità è scritto per primo, poi il codice di produzione necessaria per superare la prova è implementata, e, infine, il software è riscritta per adattarsi ai cambiamenti. La disponibilità di test prima sviluppo reale assicura un rapido feedback dopo ogni cambiamento. Praticanti sottolineano che lo sviluppo test-driven è un metodo di progettazione di software, non solo un metodo di test. sviluppo test-driven è una pratica potente e un importante contributo alla riduzione dei difetti riscontrati in seguito nel ciclo di vita. Un nuovo team è fortemente incoraggiata da abbinare con un professionista con esperienza TDD o in altro modo ricevere TDD coaching.e

sviluppo test-driven richiede che un test di unità automatizzata, definizione dei requisiti del codice, viene scritta prima di ogni aspetto del codice stesso. Questi test contengono affermazioni che sono o vere o false. Eseguire i test dà una rapida conferma del corretto comportamento come il codice si evolve e si refactoring. framework di test basati sul concetto xUnit forniscono un meccanismo per creare ed usare gruppi di casi di test automatizzati. Ciclo di sviluppo Test-Driven:. La seguente sequenza si basa sul libro Test-Driven Development con l'esempio, che molti considerano essere il testo di partenza canonica sul concetto nella sua forma moderna

  1. Scrivi un test. Nello sviluppo test-driven, ogni nuova scheda storia inizia con la scrittura di un test. Questo test avrà esito negativo perché è scritto prima che la funzione è stata implementata. Per scrivere un test, lo sviluppatore deve capire le specifiche ei requisiti della funzione in modo chiaro. Questo può essere realizzato attraverso carte di Storia con criteri di accettazione per specificare quando i requisiti è stata incontrano. Questo potrebbe anche implicare un invariante, o della modifica di un controllo esistente. Questa è una caratteristica differenziante di sviluppo test-driven contro unit test per iscritto dopo il codice è scritto:. Rende l'attenzione degli sviluppatori sui requisiti prima di scrivere il codice, una differenza sottile ma importante
  2. Eseguire tutti i test e vedere se il nuovo fallisce. Ciò conferma che il cablaggio test funziona correttamente e che il nuovo test non erroneamente passare senza richiedere alcun nuovo codice. Il nuovo test deve anche fallire per la ragione previsto. Questo passaggio verifica la prova stessa, in senso negativo:., Esclude la possibilità che il nuovo test sarà sempre passare, e quindi senza valore
  3. scrivere del codice. Il passo successivo è quello di scrivere del codice che causerà la prova di passare. Il nuovo codice scritto in questa fase non sarà perfetto e può, ad esempio, superare la prova in modo poco elegante. Questo è accettabile perché passi successivi saranno migliorare e affinare esso. E 'importante che il codice scritto è stato progettato solo per superare la prova; Non ci sono altre (e quindi non testato), la funzionalità dovrebbe essere previsto e 'consentito per' in qualsiasi momento.
  4. Esegui i test automatizzati e vedere ad avere successo. Se tutti i casi di test ora passano, il programmatore può essere sicuri che il codice soddisfa tutti i requisiti testati. Questo è un buon punto da cui iniziare la fase finale del ciclo.
  5. Codice Refactor. Ora il codice può essere pulito se necessario. Eseguendo nuovamente i casi di test, lo sviluppatore può essere certi che il refactoring non è dannoso qualsiasi funzionalità esistenti. Il concetto di rimozione di duplicazione è un aspetto importante di qualsiasi progetto software. In questo caso, tuttavia, si applica anche a rimuovere qualsiasi duplicazione tra il codice di prova e il codice di produzione-. Per esempio i numeri magici o stringhe che sono state ripetute in entrambi, al fine di far passare il test di al punto 3

Ripeti

A partire con un altro nuovo test, il ciclo viene poi ripetuto a spingere in avanti la funzionalità. La dimensione dei passi può essere piccolo come lo sviluppatore ama, o ottenere più grande, se s / si sente più sicuro. Se il codice scritto per soddisfare un test non abbastanza rapidamente farlo, allora il passo dimensioni potrebbe essere stato troppo grande, e forse i passi testabili più piccoli dovrebbe essere usato al posto. Quando si utilizza librerie esterne è importante non fare incrementi che sono così piccole da essere efficace solo testare la libreria stessa, a meno che non ci sia qualche ragione di credere che la biblioteca è buggy o non è sufficientemente completa di funzioni per servire tutte le esigenze del programma principale in fase di scrittura.

Stile miglioramento Ci sono vari aspetti di utilizzare test-driven development, ad esempio, i principi di "Keep It Simple, Stupid" (KISS) e "you are not gonna need it" (YAGNI). Focalizzando l'attenzione sulla scrittura solo il codice necessario per superare le prove, i disegni possono essere più pulito e più chiara è spesso ottenuta con altri metodi. Test-driven development richiede al programmatore di prima fallire i casi di test. L'idea è di garantire che il test funziona davvero e può prendere un errore. Una volta che questo è mostrato, il ciclo normale inizierà. Questo è stato coniato il "Test-Driven Development Mantra", conosciuto come rosso / verde / refactoring in cui i mezzi rossi falliscono e il verde è passata. sviluppo test-driven ripete costantemente le fasi di aggiungere casi di test che non riescono, li passa, e refactoring. Ricevere i risultati del test attesi in ogni fase rafforza modello mentale del programmatore del codice, aumenta la fiducia e aumenta la produttività

Si è assolutamente corretto che coppia-programmazione aiuterà immensamente quando si impara qualcosa di nuovo. Sono d'accordo con te che si dovrebbe spingere per fare entrambe le cose.

Forse il modo migliore per gettare fuori per il responsabile non è quello di suggerire che si sta chiedendo di introdurre queste due cose nuove, allo stesso tempo. Invece, suggeriscono che si sente il modo più efficace per avviare l'attuazione TDD è che, mentre ancora ottenere il lavoro fatto, è quello di prendere solo due sviluppatori come la "squadra investigativa TDD" e farli lavorare insieme per ottenere gli strumenti appropriati impostato, consulta la tecniche, li prova, e capire che cosa dovete fare per applicarle nel proprio ambiente. Una volta che hai ottenuto che di lavoro, e hanno due persone che hanno un po 'di esperienza con esso, poi li hanno divisi e ogni sedersi con un altro sviluppatore per un paio di giorni per portare quell'altro sviluppatore fino a velocità sulle nuove tecniche. Ripetere l'operazione fino a quando tutti gli sviluppatori hanno imparato TDD.

Non convincere. Digli le ragioni che si pensa sia lavorare insieme, forse presentare alcuni dati che lo conferma, e lasciare a Lui di decidere. Se avete bisogno di convincere tutti che si tratta di una buona idea, scommetto che nessuno sta andando a prendere per troppo bene. opposizione natual.

pair programming Personalmente ho trovato funziona meglio con un esperto e uno inesperto.

Cioè vorrei puntare ad una differenza di abilità / exp di programmatori piuttosto che cercare di abbinare in modo uniforme qualificati.

i più esperti ottiene più fuori di esso da una spiegazione e di essere costretti a strutturare pensieri mentre l'inesperto ottiene possibilità di rimbalzare idee e raccogliere 'migliori pratiche'.

Per quanto riguarda TDD, io sono un grande fan. Anche in questo caso exp aiuta l'inesperto perché aiuta davvero tirare fuori il punto del test. Vale a dire non si vuole mettere alla prova assolutamente tutto ... si aggiunge a fuoco. Spesso trovo persone stanno scrivendo test senza concentrarsi su ciò che stanno cercando di raggiungere.

I test unitari sono essenziali imo ... dopotutto, una parte del personale non sarà lì in due anni di tempo. Come si può modificare il codice esistente se non c'è nulla di verificare la sua funzione nei confronti?

Bene, a seconda del direttore, si può puntare a alcuni argomenti in letteratura XP che queste pratiche sono interdipendenti. Per esempio, se non si dispone di test di unità solide, non refactoring senza pietà.

Vorrei suggerire ci si avvicina in modo incrementale, in quanto la coppia sarebbe solo per lo scopo di capire TDD, come ogni sforzo di collaborazione su un nuovo problema difficile, non è che "tutto lo sviluppo della produzione sarà fatto in coppia."

Mentre una pratica non richiede l'altro, c'è un modo 'subdolo' di introdurre sia un po 'alla volta.

Inizia con l'obiettivo di attuare TDD utilizza uno dei quadri xUnit disponibili. Trova un collega di lavoro compatibile e chiedere se per circa un'ora al giorno sarebbero disposti a lavorare con voi. "Shawn, sto provando questo nuovo strumento, vuoi darmi una mano per assicurarsi che sto facendo la cosa giusta?" funziona davvero bene.

Dopo un paio di giorni con Shawn, ripetere con Susan ...

fanno comunque. Se il gestore catture si accoppiamento, dire le parole magiche "Code Review"
Assunzione: Ovviamente la coppia dovrebbe essere disciplinato / focalizzato abbastanza e produrre il codice di lavoro al termine della sessione

Scrivi alcuni test che portano l'attenzione a bug esistenti nella base di codice - poi mostrare al tuo capo, penso che potrebbe improvvisamente d'accordo TDD è una buona idea

!
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top