टीडीडी के बिना इकाई परीक्षणों की नब्ज


28

हमारे पास नई (काफी बड़ी) परियोजना शुरू है, जिसे हमने टीडीडी के उपयोग से विकसित करने की योजना बनाई है।

टीडीडी का विचार विफल रहा (कई व्यावसायिक और गैर-व्यावसायिक कारण), लेकिन अभी हमारे पास एक वार्तालाप है - क्या हमें वैसे भी इकाई परीक्षण लिखना चाहिए, या नहीं। मेरे मित्र का कहना है कि टीडीडी के बिना इकाई परीक्षणों को लिखने में कोई (या शून्य के करीब) अर्थ नहीं है, हमें केवल एकीकरण परीक्षणों पर ध्यान देना चाहिए। मैं इसके विपरीत मानता हूं, कि सादा इकाई परीक्षणों को लिखने में अभी भी कुछ समझदारी है, बस कोड को अधिक भविष्य के लिए बनाने के लिए। तुम क्या सोचते हो?

जोड़ा गया: मुझे लगता है कि यह डुप्लिकेट नहीं है >> यह प्रश्न << - मैं यूटी और टीडीडी के बीच अंतर को समझता हूं। मेरा सवाल मतभेदों के बारे में नहीं है , लेकिन टीडीडी के बिना यूनिट टेस्ट लिखने की भावना के बारे में है


22
मैं उत्सुक हूं कि आपके मित्र ने इस तरह के बेतुके रुख के लिए क्या तर्क दिया है ...
टेलस्टीन

11
मैं चाहता हूं कि कुछ यूनिट परीक्षणों वाली अधिकांश परियोजनाएं TDD का उपयोग नहीं कर रही हैं।
केसी

2
आपका एकीकरण स्तर क्या होगा? आपकी इकाइयाँ क्या होंगी? कितनी बार आप प्रत्येक परीक्षण स्तर से नीचे का रीफैक्टरिंग करेंगे? आपके एकीकरण परीक्षण कितनी तेजी से चलेंगे? उन्हें लिखना कितना आसान होगा? आपके कोड के विभिन्न भागों में कितने कॉम्बिनेटरियल मामले उत्पन्न होते हैं? आदि ... यदि आप इनका उत्तर नहीं जानते हैं, तो शायद दृढ़ निर्णय लेने की जल्दी है। कभी-कभी टीडीडी महान है। कभी-कभी लाभ कम स्पष्ट होते हैं। कभी-कभी यूनिट परीक्षण आवश्यक होते हैं। कभी-कभी एकीकरण परीक्षणों का एक सभ्य सेट आपको लगभग उतना ही खरीदता है, और बहुत अधिक लचीला होता है ... अपने विकल्प खुले रखें।
Topo Reinstate Monica

2
अनुभव से कुछ व्यावहारिक सलाह के रूप में, अगर आप टीडीडी नहीं कर रहे हैं तो सब कुछ परीक्षण न करें। यह निर्धारित करने के लिए कि किस प्रकार के परीक्षण मूल्यवान हैं। मैंने पाया है कि शुद्ध इनपुट / आउटपुट विधियों पर यूनिट परीक्षण असाधारण रूप से मूल्यवान हैं, जबकि एप्लिकेशन के बहुत उच्च स्तर पर एकीकरण परीक्षण (जैसे, वास्तव में वेब एप्लिकेशन पर वेब अनुरोध भेजना) भी असाधारण रूप से मूल्यवान हैं। मध्य-स्तरीय एकीकरण परीक्षण और यूनिट परीक्षणों के लिए देखें, जिनमें बहुत सारे नकली सेट की आवश्यकता होती है। इसके अलावा इस वीडियो को देखने: youtube.com/watch?v=R9FOchgTtLM
jpmc26

आपका अपडेट आपके द्वारा पूछे गए प्रश्न के संबंध में कोई मतलब नहीं रखता है। यदि आप टीडीडी और यूनिट टेस्ट के बीच अंतर को समझते हैं, तो आपको यूनिट परीक्षण लिखने से क्या रोकना है। अपने प्रश्न को छोड़ने के लिए मतदान बंद कर दिया गया था, हालांकि मैं नकल के बजाय "अस्पष्ट क्या आप पूछ रहे हैं" के रूप में बंद करने के लिए एक तर्क देख सकता था।

जवाबों:


52

TDD का उपयोग मुख्य रूप से (1) कवरेज सुनिश्चित करने के लिए, (2) और रखरखाव योग्य, समझने योग्य, परीक्षण योग्य डिजाइन को चलाने के लिए किया जाता है। यदि आप TDD का उपयोग नहीं करते हैं, तो आपको गारंटीकृत कोड कवरेज नहीं मिलता है। लेकिन किसी भी तरह से इसका मतलब यह नहीं है कि आपको उस लक्ष्य को छोड़ देना चाहिए और 0% कवरेज के साथ आनंद से जीना चाहिए।

एक कारण के लिए प्रतिगमन परीक्षण का आविष्कार किया गया था। कारण यह है कि लंबे समय में, वे आपको अतिरिक्त त्रुटियों को रोकने में अधिक समय बचाते हैं, क्योंकि वे लिखने के लिए अतिरिक्त प्रयास करते हैं। यह बार-बार साबित हुआ है। इसलिए, जब तक कि आप को गंभीरता से मानना है कि अपने संगठन के बहुत, बहुत बेहतर सभी गुरुओं जो प्रतिगमन परीक्षण की सिफारिश की तुलना में सॉफ्टवेयर इंजीनियरिंग में है (या आप बहुत जल्द ही इतना है कि वहाँ नीचे जा रहा पर योजना अगर है कोई लंबी आप के लिए आ जाते है), हाँ, आप पूरी तरह से इकाई परीक्षण होना चाहिए, ठीक उसी कारण से जो दुनिया के लगभग हर दूसरे संगठन पर लागू होता है: क्योंकि वे एकीकरण परीक्षणों से पहले की त्रुटियों को पकड़ते हैं, और इससे आपको धन की बचत होगी। उन्हें न लिखना सड़क पर इधर-उधर पड़े हुए मुफ्त पैसे पास करने जैसा है।


12
"यदि आप TDD का उपयोग नहीं करते हैं, तो आपको गारंटीकृत कोड कवरेज नहीं मिलता है।": मुझे नहीं लगता। आप दो दिनों के लिए विकसित कर सकते हैं, और अगले दो दिनों के लिए आप परीक्षण लिखते हैं। महत्वपूर्ण बिंदु यह है कि जब तक आपके पास वांछित कोड कवरेज न हो, तब तक आप एक विशेषता को समाप्त नहीं मानते हैं।
जियोर्जियो

5
@DougM - एक आदर्श दुनिया में शायद ...
टेलस्टीन

7
अफसोस की बात है कि टीडीडी हाथ से हाथ मिलाने के साथ-साथ चलता रहता है और जब तक लोग ऐसा करना बंद नहीं करते हैं, तब तक यह साबित हो जाता है कि आपका परीक्षण तेजी से चल रहा हैटीडीडी मर चुका है। लंबे समय तक जीवित परीक्षण।
मिकडी

17
TDD कोड कवरेज की गारंटी नहीं देता है। यह एक खतरनाक धारणा है। आप परीक्षणों के खिलाफ कोड कर सकते हैं, उन परीक्षणों को पास कर सकते हैं, लेकिन फिर भी किनारे के मामले हैं।
रॉबर्ट हार्वे

4
@ मिक्की डंकन मुझे पूरा यकीन नहीं है कि मैं आपकी चिंता को पूरी तरह से समझता हूं। मॉकिंग एक पूरी तरह से मान्य तकनीक है जिसका उपयोग एक घटक को दूसरों से अलग करने के लिए किया जाता है ताकि उस घटक के व्यवहार का परीक्षण स्वतंत्र रूप से किया जा सके। हां, इसे चरम सीमा तक ले जाया जा सकता है, यह अति-इंजीनियर सॉफ्टवेयर को जन्म दे सकता है, लेकिन यदि अनुपयुक्त रूप से उपयोग किया जाता है, तो यह किसी भी विकास तकनीक का उपयोग कर सकता है। इसके अलावा, जैसा कि डीएचएच बताता है कि लेख में आप उद्धृत करते हैं, केवल पूर्ण प्रणाली परीक्षणों का उपयोग करने का विचार केवल उतना ही बुरा है, अगर वास्तव में बुरा नहीं है। किसी विशेष सुविधा के परीक्षण का सबसे अच्छा तरीका क्या है यह तय करने के लिए निर्णय का उपयोग करना महत्वपूर्ण है
जूल्स

21

मेरे पास अभी के लिए एक प्रासंगिक किस्सा है जो अभी मेरे लिए चल रहा है। मैं एक ऐसी परियोजना पर हूं जो टीडीडी का उपयोग नहीं करता है। हमारे क्यूए लोग हमें उस दिशा में आगे बढ़ा रहे हैं, लेकिन हम एक छोटे संगठन हैं और यह एक लंबी, खींची गई प्रक्रिया है।

वैसे भी , मैं हाल ही में एक विशिष्ट कार्य करने के लिए तीसरे पक्ष के पुस्तकालय का उपयोग कर रहा था। उस पुस्तकालय के उपयोग के संबंध में एक समस्या थी, इसलिए मुझे अनिवार्य रूप से उसी पुस्तकालय के एक संस्करण को लिखने के लिए मुझ पर डाल दिया गया। कुल मिलाकर, यह निष्पादन योग्य कोड की लगभग 5,000 पंक्तियों और मेरे समय के लगभग 2 महीनों में समाप्त हो गया। मुझे पता है कि कोड की लाइनें एक खराब मीट्रिक है, लेकिन इस उत्तर के लिए मुझे लगता है कि यह परिमाण का एक अच्छा संकेतक है।

एक विशेष डेटा संरचना थी जिसकी मुझे आवश्यकता थी जो मुझे बिट्स की एक मनमानी संख्या पर नज़र रखने की अनुमति देगा। चूंकि परियोजना जावा में है, इसलिए मैंने जावा को चुना BitSetऔर इसे थोड़ा संशोधित किया (मुझे अग्रणी 0एस को ट्रैक करने की क्षमता की आवश्यकता थी , जो कि जावा का बिटसेट किसी कारण से नहीं करता है .....)। ~ 93% कवरेज तक पहुंचने के बाद मैंने कुछ परीक्षण लिखना शुरू किया जो वास्तव में मेरे द्वारा लिखी गई प्रणाली पर जोर देगा। मुझे यह सुनिश्चित करने के लिए कार्यक्षमता के कुछ पहलुओं को बेंचमार्क करने की आवश्यकता थी कि वे मेरी अंतिम आवश्यकताओं के लिए पर्याप्त तेज़ होंगे। अप्रत्याशित रूप से, BitSetइंटरफ़ेस से मैंने जिन कार्यों को ओवरराइड किया था, उनमें से एक बड़े बिट सेट्स (इस मामले में लाखों बिट्स के सैकड़ों) के साथ काम करते समय बेतुका धीमा था। अन्य ओवरराइड किए गए फ़ंक्शंस इस एक फ़ंक्शन पर निर्भर थे, इसलिए यह एक बड़ी बोतल गर्दन थी।

मैंने जो किया, वह ड्राइंग बोर्ड में जा रहा था, और अंतर्निहित संरचना में हेरफेर करने का एक तरीका पता लगा रहा था BitSet, जो कि ए long[]। मैंने एल्गोरिथ्म को डिज़ाइन किया, उनके इनपुट के लिए सहयोगियों से पूछा, और फिर मैंने कोड लिखने के बारे में सेट किया। फिर, मैंने यूनिट परीक्षणों को चलाया। उनमें से कुछ टूट गए, और जिन लोगों ने मुझे ठीक करने के लिए मुझे अपने एल्गोरिथ्म में देखने की आवश्यकता थी, ठीक उसी ओर इशारा किया। यूनिट परीक्षणों से सभी त्रुटियों को ठीक करने के बाद, मैं यह कहने में सक्षम था कि फ़ंक्शन उसी तरह काम करता है जैसा कि इसे करना चाहिए। बहुत कम से कम, मुझे विश्वास हो सकता है कि इस नए एल्गोरिथ्म ने पिछले एल्गोरिथम के साथ-साथ काम किया।

बेशक, यह बुलेट प्रूफ नहीं है। अगर मेरे कोड में एक बग है जिसे यूनिट परीक्षण के लिए जाँच नहीं कर रहा है, तो मुझे यह पता नहीं चलेगा। लेकिन निश्चित रूप से, यह वही बग मेरे धीमी एल्गोरिथ्म में भी हो सकता था। हालांकि , मैं विश्वास के उच्च स्तर के साथ कह सकता हूं कि मुझे उस विशेष फ़ंक्शन से गलत आउटपुट के बारे में चिंता करने की आवश्यकता नहीं है। पहले से मौजूद इकाई परीक्षणों ने मुझे सही करने के लिए नए एल्गोरिथ्म का परीक्षण करने के प्रयास के घंटों, शायद दिनों की बचत की।

टीडीडी की परवाह किए बिना यूनिट टेस्ट होने की बात यह है - कहने का मतलब यह है कि यूनिट टेस्ट आपको टीडीडी में और टीडीडी के बाहर सभी के लिए एक समान करेगा, जब आप कोड को रीफैक्टरिंग / मेंटेन करते हैं। बेशक, इसे नियमित प्रतिगमन परीक्षण, धुआं परीक्षण, फजी परीक्षण, आदि के साथ जोड़ा जाना चाहिए, लेकिन इकाई परीक्षण, जैसा कि नाम बताता है, सबसे छोटी, परमाणु स्तर पर चीजों का परीक्षण करता है, जो आपको दिशा देता है जहां त्रुटियां पॉप अप हुई हैं।

मेरे मामले में, मौजूदा यूनिट परीक्षणों के बिना, मुझे किसी भी समय एल्गोरिथम को सुनिश्चित करने की एक विधि के साथ आना होगा। जो, अंत में ... इकाई परीक्षण की तरह लगता है , है ना?


7

आप कोड को लगभग 4 श्रेणियों में तोड़ सकते हैं:

  1. सरल और शायद ही कभी बदलता है।
  2. सरल और अक्सर बदलता है।
  3. जटिल और शायद ही कभी बदलता है।
  4. जटिल और अक्सर बदलता है।

यूनिट परीक्षण अधिक मूल्यवान हो जाते हैं (महत्वपूर्ण कीड़े को पकड़ने की संभावना) आपके द्वारा जाने वाली सूची के आगे। मेरी व्यक्तिगत परियोजनाओं में, मैं लगभग हमेशा श्रेणी 4 पर टीडीडी करता हूं। श्रेणी 3 पर मैं आमतौर पर टीडीडी करता हूं जब तक कि मैनुअल परीक्षण सरल और तेज नहीं होता है। उदाहरण के लिए, एंटीअलियासिंग कोड लिखना जटिल होगा, लेकिन इकाई परीक्षण लिखने की तुलना में नेत्रहीन रूप से सत्यापित करने के लिए बहुत आसान है, इसलिए इकाई परीक्षण केवल मेरे लिए इसके लायक होगा यदि वह कोड अक्सर बदल जाता है। मेरे फंक्शन के बाकी कोड मैंने केवल यूनिट टेस्ट के तहत रखे थे क्योंकि मुझे उस फ़ंक्शन में एक बग मिला।

यह कभी-कभी पहले से जानना मुश्किल होता है कि किस श्रेणी का एक निश्चित ब्लॉक किस श्रेणी में फिट बैठता है। टीडीडी का मूल्य है कि आप गलती से किसी भी जटिल इकाई परीक्षण को याद नहीं करते हैं। टीडीडी की लागत हर समय है जब आप सरल इकाई परीक्षण लिखने में खर्च करते हैं। हालांकि, आमतौर पर एक परियोजना के साथ अनुभव किए गए लोग निश्चितता की एक उचित डिग्री के साथ जानते हैं कि कोड के विभिन्न भाग किस श्रेणी में फिट होते हैं। यदि आप टीडीडी नहीं कर रहे हैं, तो आपको कम से कम सबसे मूल्यवान परीक्षण लिखने की कोशिश करनी चाहिए।


1
जब आप कोड पर काम कर रहे हों, जैसे आप अपने एंटीएलियासिंग उदाहरण के साथ सुझाव देते हैं, तो मुझे लगता है कि सबसे अच्छी बात यह है कि कोड को प्रयोगात्मक रूप से विकसित करना है, फिर यह सुनिश्चित करने के लिए कुछ लक्षण वर्णन परीक्षण जोड़ें कि मैं गलती से बाद में एल्गोरिथ्म को नहीं तोड़ता। चरित्र परीक्षण बहुत जल्दी और आसानी से विकसित होते हैं, इसलिए ऐसा करने का ओवरहेड बहुत कम है।
जूल्स

1

चाहे वह इकाई, घटक, एकीकरण या स्वीकृति परीक्षण हो, महत्वपूर्ण हिस्सा यह है कि इसे स्वचालित होना चाहिए। स्वचालित परीक्षण न होना किसी भी तरह के सॉफ्टवेयर के लिए एक सामान्य गलती है, जिसमें साधारण सीआरयूडी से लेकर सबसे जटिल गणना शामिल है। तर्क यह है कि स्वचालित परीक्षणों को लिखना हमेशा परिमाण के आदेशों द्वारा सभी परीक्षणों को मैन्युअल रूप से चलाने की निरंतर आवश्यकता से कम खर्च होगा। आपके द्वारा उन्हें लिखे जाने के बाद, आपको बस यह देखने के लिए एक बटन पुश करना होगा कि वे पास होते हैं या विफल। मैनुअल परीक्षणों को चलाने में हमेशा लंबा समय लगेगा, और मनुष्यों (जीवित प्राणी जो ऊब गए हैं, पर ध्यान देने की कमी हो सकती है) पर निर्भर करता है कि क्या परीक्षण पास करने में विफल होते हैं या नहीं। संक्षेप में, हमेशा स्वचालित परीक्षण लिखें।

अब, इस कारण से कि आपका सहयोगी टीडीडी के बिना किसी भी प्रकार की इकाई परीक्षण करने के खिलाफ हो सकता है: यह शायद इसलिए है क्योंकि उत्पादन कोड के बाद लिखे गए परीक्षणों पर भरोसा करना कठिन है। और अगर आप अपने स्वचालित परीक्षणों पर भरोसा नहीं कर सकते हैं, तो वे कुछ भी नहीं के लायक हैं । टीडीडी चक्र के बाद, आपको सबसे पहले एक परीक्षण में असफल होना चाहिए (सही कारण के लिए) इसे पास करने के लिए उत्पादन कोड लिखने की अनुमति दी जानी चाहिए (और नहीं)। यह प्रक्रिया अनिवार्य रूप से आपके परीक्षणों का परीक्षण कर रही है, इसलिए आप उन पर भरोसा कर सकते हैं। इस तथ्य का उल्लेख नहीं करने के लिए कि वास्तविक कोड से पहले परीक्षण लिखना आपको अपनी इकाइयों और घटकों को अधिक आसानी से परीक्षण करने योग्य बनाने के लिए धक्का देता है (उच्च स्तर के डीकोपिंग, एसआरपी लागू, आदि ...)। हालांकि, ज़ाहिर है, टीडीडी करने से अनुशासन होता है

इसके बजाय, यदि आप सभी उत्पादन कोड पहले लिखते हैं, जब आप इसके लिए परीक्षण लिखते हैं, तो आप उनसे पहले भाग में पास होने की उम्मीद करेंगे। यह बहुत ही समस्याग्रस्त है, क्योंकि आपने एक परीक्षण बनाया होगा जो आपके उत्पादन कोड के 100% को कवर करता है, बिना सही व्यवहार का दावा किए (हो सकता है कि कोई दावा भी नहीं कर रहा हो ! मैंने ऐसा होता देखा है ), क्योंकि आप इसे विफल नहीं देख सकते हैं! पहले यह जांचने के लिए कि क्या यह सही कारण के लिए असफल है। इस प्रकार, आप गलत-सकारात्मक हो सकते हैं। गलत-सकारात्मक अंततः आपके परीक्षण सूट में विश्वास को तोड़ देंगे, अनिवार्य रूप से लोगों को फिर से मैनुअल परीक्षण का सहारा लेने के लिए मजबूर करते हैं, इसलिए आपके पास दोनों प्रक्रियाओं (लेखन परीक्षण + मैनुअल परीक्षण) की लागत है।

इसका मतलब है कि आपको अपने परीक्षण का एक और तरीका खोजना होगा , जैसे कि टीडीडी करता है। तो आप डिबगिंग का सहारा लेते हैं, उत्पादन कोड के कुछ हिस्सों पर टिप्पणी करते हैं, आदि, ताकि परीक्षणों पर भरोसा करने में सक्षम हो सकें। समस्या यह है कि "आपके परीक्षणों का परीक्षण करने" की प्रक्रिया इस तरह से बहुत धीमी है। इस समय को जोड़ते हुए कि आप मैन्युअल रूप से तदर्थ परीक्षण चलाने में खर्च करेंगे (क्योंकि आपके पास उत्पादन कोड को कोड करते समय स्वचालित परीक्षण नहीं हैं), मेरे अनुभव में, एक समग्र प्रक्रिया में परिणाम होता है जो अभ्यास करने की तुलना में बहुत धीमा है। TDD "पुस्तक द्वारा" (केंट बेक - TDD उदाहरण के लिए)। इसके अलावा, मैं यहां एक शर्त लगाने के लिए तैयार हूं और कहता हूं कि वास्तव में "आपके परीक्षणों का परीक्षण" करने के बाद उन्हें लिखा गया था कि टीडीडी की तुलना में बहुत अधिक अनुशासन है।

तो हो सकता है कि आपकी टीम TDD न करने के लिए "व्यवसाय और गैर-व्यावसायिक कारणों" पर पुनर्विचार कर सकती है। मेरे अनुभव में, लोगों को लगता है कि कोड पूरा होने के बाद सिर्फ टीडीडी लिखने की तुलना में टीडीडी धीमा है। यह धारणा त्रुटिपूर्ण है, जैसा कि आप ऊपर पढ़ चुके हैं।


0

अक्सर परीक्षणों की गुणवत्ता उनकी सिद्धता पर निर्भर करती है। मैं नियमित रूप से 'वास्तविक' टीडीडी नहीं करने का दोषी हूं - मैं यह साबित करने के लिए कुछ कोड लिखता हूं कि मैं वास्तव में काम करने वाली रणनीति का उपयोग करना चाहता हूं, फिर प्रत्येक मामले को कवर करें जो कोड बाद में परीक्षण के साथ समर्थन करने के लिए है। आमतौर पर कोड की इकाई एक वर्ग है, जो आपको सामान्य रूप से यह बताने के लिए कि मैं टेस्ट कवरेज के बिना खुशी से कितना काम करूंगा - यह कहना है, बड़ी राशि नहीं। इसका मतलब यह है कि परीक्षणों का शब्दार्थ अर्थ अपनी 'समाप्त' स्थिति में परीक्षण के तहत प्रणाली के साथ अच्छी तरह मेल खाता है - क्योंकि मैंने उन्हें यह जानते हुए लिखा था कि SUT क्या मामलों को पूरा करता है और कैसे उन्हें पूरा करता है।

इसके विपरीत, TDD आक्रामक आक्रामक नीति के साथ अप्रचलित परीक्षणों को कम से कम उतनी ही तेजी से आगे बढ़ाता है जितना कि आप उन्हें परीक्षण परिवर्तनों के तहत सिस्टम के सार्वजनिक इंटरफ़ेस के रूप में लिख सकते हैं। मैं व्यक्तिगत रूप से आवेदन की कार्यात्मक इकाइयों को डिजाइन करने और परीक्षणों के शब्दार्थ को ध्यान में रखते हुए दोनों का मानसिक काम का बोझ पाता हूं जो मेरी एकाग्रता बनाए रखने के लिए इसे बहुत अधिक मात्रा में कवर करता है और परीक्षण रखरखाव अक्सर फिसल जाता है। कोडबेस उन परीक्षणों के साथ समाप्त होता है जो चारों ओर लटके हुए हैं जो किसी भी चीज़ का परीक्षण नहीं करते हैं या केवल सादे गलत हैं। यदि आपके पास हर तरह से परीक्षण सूट को अद्यतित रखने के लिए अनुशासन और मानसिक क्षमता है, तो TDD का अभ्यास उतना ही करें, जितना आप चाहते हैं। मैं नहीं करता, इसलिए मैंने इसे इस कारण कम सफल पाया है।


0

वास्तव में अंकल बॉब ने अपने एक स्वच्छ कोडर्स वीडियो में एक बहुत ही दिलचस्प बिंदु का उल्लेख किया। उन्होंने कहा कि रेड-ग्रीन-रिफ्लेक्टर चक्र को 2 तरीकों से लागू किया जा सकता है।

1 पारंपरिक टीडीडी तरीका है। फेलिंग टेस्ट लिखें फिर टेस्ट पास करें और अंत में रिफ्लेक्टर।

दूसरा तरीका उत्पादन कोड का एक बहुत छोटा सा टुकड़ा लिखना है और तुरंत उसके यूनिट परीक्षण द्वारा फिर रिफ्लेक्टर का पालन करना है।

विचार बहुत छोटे चरणों में जाना है । बेशक आप उत्पादन कोड से सत्यापन खो देते हैं कि आपका परीक्षण लाल से हरे रंग में चला गया था, लेकिन कुछ मामलों में जहां मैं ज्यादातर जूनियर डेवलपर्स के साथ काम कर रहा था, जिन्होंने टीडीडी को समझने की कोशिश करने से भी इनकार कर दिया, यह कुछ हद तक प्रभावी साबित हुआ।

फिर से मैं दोहराता हूं (और यह अंकल बॉब द्वारा जोर दिया गया था) विचार बहुत छोटे चरणों में जाने और उत्पादन कोड के टुकड़े का तुरंत परीक्षण करने के लिए है जो अभी जोड़ा गया था।


"... विचार बहुत छोटे चरणों में जाना है और तुरंत उत्पादन कोड के टुकड़े का परीक्षण करना है जो अभी जोड़ा गया था।": मैं सहमत नहीं हूं। जब आप अच्छा करते हैं तो आप क्या वर्णन करते हैं, यह पहले से ही स्पष्ट है कि आप क्या करना चाहते हैं और आप विवरण पर काम करना चाहते हैं, लेकिन आपको पहले बड़ी तस्वीर प्राप्त करने की आवश्यकता है। अन्यथा, बहुत छोटे चरणों में जाकर (परीक्षण, विकास, परीक्षण, विकास) आप विवरण में खो सकते हैं। "यदि आप नहीं जानते कि आप कहाँ जा रहे हैं तो आप वहाँ नहीं पहुँच सकते।"
जियोर्जियो
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.