सिद्धांत में ही TDD


29

एक साल पहले मैं काम से 9 महीने की छुट्टी लेने में सक्षम होने के लिए भाग्यशाली था। मैंने तय किया कि उस समय में मैं अपने सी # कौशल को सुधारूंगा। मैंने परियोजनाओं के एक समूह पर काम करना शुरू किया और अपने आप को टीडीडी का पालन करने के लिए मजबूर किया।

यह काफी ज्ञानवर्धक प्रक्रिया थी।

यह पहली बार में कठिन था, लेकिन समय के साथ मैंने सीखा कि अधिक परीक्षण योग्य कोड कैसे लिखें (जो, जैसा कि यह पता चला है, अधिक ठोस कोड हो जाता है) और इस प्रक्रिया में मैंने अपने ओओ डिजाइन कौशल को भी तेज किया।

अब मैं कार्यबल में वापस आ गया हूं और कुछ अजीब देख रहा हूं।

मैं टीडीडी का पालन नहीं करना पसंद करता हूं।

मुझे पता है कि टीडीडी मुझे धीमा कर देता है और वास्तव में एक साफ आवेदन डिजाइन करना कठिन हो जाता है।

इसके बजाय, मैंने थोड़ा (बड़े पैमाने पर) अलग दृष्टिकोण अपनाया है:

  1. काम का एक ऊर्ध्वाधर टुकड़ा उठाओ
  2. एक कार्यशील प्रोटोटाइप विकसित करें
  3. सब कुछ अच्छा और सुव्यवस्थित होने तक रिफ्लेक्टर
  4. मेरे द्वारा लिखे गए खूबसूरती से ठोस और परीक्षण योग्य कोड की सराहना करें।

आपने देखा होगा कि चरण 1 "मेरे परीक्षण लक्ष्य की सार्वजनिक सतह को परिभाषित नहीं करता था" और चरण 2 में "उक्त सार्वजनिक सतह से बेजेस का परीक्षण नहीं किया गया था।" आपने यह भी देखा होगा कि परीक्षण में कोई भी कदम शामिल नहीं है। मैं परीक्षण योग्य कोड लिख रहा हूं, लेकिन मैं इसका परीक्षण नहीं कर रहा हूं ... अभी तक।

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

मैं यह भी स्पष्ट करना चाहूंगा कि मैं सभी स्वचालित परीक्षण का उपयोग नहीं कर रहा हूँ। यह वह जगह है जहाँ मेरी प्रक्रिया अलग है। और यही कारण है कि मैं यह सवाल पूछ रहा हूं।

सिद्धांत में TDD। व्यवहार में नहीं।

मेरी प्रक्रिया थोड़ी विकसित हुई है और मैंने TDD और बिना किसी परीक्षण के बीच एक संतुलन बनाया है, जो मुझे बहुत उपयोगी लगता है और यथोचित सुरक्षित भी है। यह इस प्रकार है:

  1. काम के परीक्षण में काम कर रहे ऊर्ध्वाधर टुकड़ा को ध्यान में रखते हुए लागू करें, लेकिन कोई परीक्षण न लिखें।
  2. यदि नीचे सड़क (जैसे, एक महीने बाद) कि स्लाइस में संशोधन की आवश्यकता है
    1. यूनिट टेस्ट, इंटीग्रेशन टेस्ट, बिहेवियर टेस्ट आदि लिखें जो काम के स्लाइस की गारंटी देते हैं
    2. कोड को संशोधित करें
  3. यदि उस स्लाइस में संशोधन की आवश्यकता नहीं है,
    1. कुछ मत करो

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

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

तो, क्या मैं [बीटी] डीडी नरक में जा रहा हूं, या यह व्यावहारिक कोडिंग और परीक्षण का एक सामान्य रूप है?

मैं इस तरह काम करते रहना चाहूंगा। मैं लंबी अवधि में इस प्रक्रिया को काम करने के लिए क्या कर सकता हूं?

ध्यान दें:

मैं अपनी परियोजनाओं पर एकमात्र डेवलपर हूं और मैं हर चीज के लिए जिम्मेदार हूं: आवश्यकताएं इकट्ठा करना, डिजाइन, वास्तुकला, परीक्षण, तैनाती, आदि। मुझे संदेह है कि मेरी प्रक्रिया क्यों काम कर रही है।


2
स्पाइक की तरह लग रहा है और बाहर के साथ हमेशा स्थिर अगर कर रहा है If that slice doesn't need modificationlizkeogh.com/2012/06/24/beyond-test-driven-development
RubberChickenLeader

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

5
हां, और पहले परीक्षण लिखना अनिवार्य रूप से आपके प्रोटोटाइपिंग कार्य को दोगुना कर देता है।
रॉबर्ट हार्वे

3
इसका मतलब है कि मैं इसके बारे में झूठ बोल रहा था "थोड़ा।"
मेटाफाइट

1
"और, जब मैं लिखने के परीक्षण के आसपास हो जाता हूं, तो मैं उनमें से बहुत कम लिखता हूं, लेकिन लगभग जमीन (उच्च आरओआई) को कवर करता हूं" जब आप कहते हैं कि उनमें से बहुत कम लिखें, तो क्या आपका मतलब सिर्फ यह है कि आप केवल कोड का परीक्षण कर रहे हैं ' फिर से बदल रहा है, या आप कह रहे हैं कि आप किसी तरह एक ही (परीक्षण किए गए) कोड को कम परीक्षणों के साथ कवर कर रहे हैं यदि आपने टीडीडी का उपयोग किया है?
बेन आरोनसन

जवाबों:


6

लंबी अवधि में प्रक्रिया को काम करने के लिए मैं परीक्षण लिखूंगा जब कोड लिखा जा रहा हो।

जो आपके दृष्टिकोण के विपरीत लग सकता है। हालाँकि आपने प्रश्न को प्रस्तुत कर दिया है, इसलिए मैं आपको अपना ले लूंगा:

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

इसे बाद में छोड़ने का मतलब है कि समय के साथ ज्ञान (स्वाभाविक रूप से) कम हो जाएगा।

इसका मतलब यह भी है कि आपको कभी भी छोड़ देना चाहिए और किसी और को अपने ऊपर ले लेना चाहिए, आपके पास दस्तावेज (परीक्षणों के माध्यम से) नहीं होने का तात्कालिक तकनीकी ऋण नहीं होगा क्या करता है।

सबसे अधिक, "किसी दिन" नहीं आ सकता है। आप या तो बस की चपेट में आ सकते हैं या आप नए रोमांच के लिए बस में चढ़ सकते हैं।

अंत में, मैन्युअल परीक्षण स्केल नहीं करता है और अक्सर अंतिम उपयोगकर्ता द्वारा उपयोग किए जाने वाले सभी उपकरणों को कवर नहीं करता है।


मुझे लगता है कि मुझे आपके सुझाए गए दृष्टिकोण पसंद हैं और मैं इसे तब लागू कर सकता हूं जब मैं कर सकता हूं। मेरा काम हालांकि बहुत खंडित है, इसलिए "घंटों का समय" हमेशा संभव नहीं है। दुर्भाग्य से मैं भी समर्थन पर हूँ इसलिए मैं अक्सर आग से लड़ने में मदद करने के लिए अपने काम से दूर हो जाता हूं :) लेकिन, यह जीवन है।
मेटाफ़ाइट

मुद्दा हालांकि यह है कि कल कभी नहीं आता है, हमेशा अगली विशेषता होती है। और तुम क्या करने के लिए चुना जा रहे हैं; अगली विशेषता लिखें, या आपके द्वारा "समाप्त हो गया" के लिए परीक्षण लिखें?
एंडी

9

हालांकि टीडीडी को 100% लागू करना कठिन है, लेकिन आपके दृष्टिकोण में दोष है

  1. काम के एक ऊर्ध्वाधर ऊर्ध्वाधर टुकड़ा को लागू करें

    1.1 1 साल गुजर गए…।

    1.2 एक नया देव परियोजना पर काम शुरू करता है

  2. यदि उस स्लाइस में संशोधन की आवश्यकता है

    २.३ पार्स 'क्लीन कोडिंग' शैली विधि के नाम और पैरामीटर 'गेटउनॉर्न (colourOfUnicorn)'

    २.४ xml टिप्पणी पढ़ें 'एक स्वर्ण गेंडा (सवारी के लिए) (obvs) हो जाता है'

    2.5 मूल देव नीचे शिकार

    2.6 आशा है कि उन्हें याद होगा कि कोड क्या करना चाहिए

    2.7 उन्हें यह सब समझाना

  3. यूनिट टेस्ट, इंटीग्रेशन टेस्ट, बिहेवियर टेस्ट आदि लिखें जो उम्मीद करते हैं कि काम के स्लाइस की गारंटी सही है

  4. कोड को संशोधित करें

मुझे लगता है कि आप यह पहचानने के लिए सही हैं कि संशोधनों की आवश्यकता होने पर यूनिट परीक्षण वास्तव में उनका मूल्य दिखाते हैं।


2
अरे, मैं स्वयं दस्तावेज कोड लिखता हूं! मेरी कक्षाओं में एक जिम्मेदारी है और इसलिए, समझना आसान है। किसी को भी मेरा शिकार करने की आवश्यकता नहीं होगी :)
मेटाफाइट

7
@ मीताफ़ाइट और अगर वे करते हैं, तो आप एकांत में रहने वाले ठोस सोने के शीर्ष पर रहना आसान करेंगे!
jonrsharpe

3
मैं उसे गोल्डिकॉर्न कहता हूं।
मेटाफाइट

अधिक गंभीर नोट पर, हां, आपके पास एक बिंदु है। मैंने "परीक्षण ऋण" कहानियों को लॉग इन करने पर विचार किया है ताकि मेरे काम का बोझ हल्का होने पर मैं कुछ भुगतान कर सकूं।
मेटाफाइट

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

4

मैं डैनियल हॉलिनरेक और इवान दोनों के साथ सहमत हूं, कि पहली महत्वपूर्ण बात यह है कि आपके परीक्षण-केवल-अगर-संशोधित अब तक अच्छी तरह से काम करता है:

I am the sole developer on my projects and I am responsible for everything

और वह संभावित दूसरा मुख्य बिंदु है:

you're producing nice clean code

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

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

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


1
मुझे लगता है कि समस्या का एक हिस्सा यह है कि केवल 1 प्रोग्रामर हो सकता है लेकिन कोड आधार अक्सर समय के साथ बढ़ेगा और जो काम किया (परीक्षण के लिए) जब यह छोटा था तो काम नहीं करता क्योंकि यह बड़ा हो जाता है।
माइकल डुरंट

3

मेरे लिए मुख्य बात यह प्रतीत होती है:

मैं अपनी परियोजनाओं पर एकमात्र डेवलपर हूं और मैं हर चीज के लिए जिम्मेदार हूं: आवश्यकताएं इकट्ठा करना, डिजाइन, वास्तुकला, परीक्षण, तैनाती, आदि। मुझे संदेह है कि मेरी प्रक्रिया क्यों काम कर रही है।

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

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

परीक्षण लिखने का एक माध्यमिक कारण यह है कि मुझे लगता है कि वे एक दस्तावेज हैं। एक समारोह क्यों बनाया गया, इसके पीछे वे मेरे तर्क बता सकते हैं। लेकिन यहाँ, मैं व्यवहार प्रेरित विकास के बारे में अधिक सोच रहा हूँ।


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

यह एक उचित बिंदु है, लेकिन मेरे अनुभव में दुख की बात है, लगभग हर परियोजना पर मैंने दस्तावेज़ीकरण पर काम किया है, जब यह मौजूद है, या तो पुराना है या अधूरा है।
डैनियल हॉलिन्रेके

1
यहां भी, यही वजह है कि देवों को चीजों के दस्तावेजीकरण के महत्व का एहसास होना चाहिए और परीक्षणों के रूप में अधिक कोड नहीं लिखना चाहिए! हो सकता है कि हमें कोड टिप्पणियों और आवश्यकता टिकटों से बेहतर प्रलेखन पीढ़ी (यानी कि विधि हस्ताक्षरों की सिर्फ सुंदर स्वरूपण) की अनुमति के लिए उपकरण की आवश्यकता न हो।
gbjbaanb

मैंने आपकी टिप्पणियों के जवाब में अपना उत्तर थोड़ा संपादित किया है। धन्यवाद।
डैनियल हॉलिनरेक

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

3

इकाई परीक्षण कोड बनाए रखने की समस्या से निपटने के बारे में है। हालांकि ऐसे लोग हैं जो कहते हैं कि वे बिना तेजी से लिखने के बजाय TDD के साथ कोड लिख रहे हैं, मुझे आश्चर्य नहीं है कि आप परीक्षण लिखने के बिना अधिक नए कोड लिखने में सक्षम हैं।

जिन मुद्दों को आप बदलने से पहले परीक्षण लिखने के अभ्यास के साथ देख सकते हैं:

मुझे अक्सर जल्दी में बदलाव करने की आवश्यकता होती है

जब आप केवल जरूरत पड़ने पर परीक्षण लिखकर समग्र रूप से समय बचा सकते हैं, तो सभी समय समान नहीं होते हैं। जब मैं संकट की स्थिति में हूं, तो 1 घंटे बचाने के लिए 2 घंटे लेखन परीक्षण खर्च करना - पूरी तरह से इसके लायक है।

जैसे ही मैं कोड लिखता हूं, उसी समय परीक्षण लिखना आसान हो जाता है

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


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

राइटिंग यूनिट परीक्षण ऑफ़सेट्स की लागत को समझती है कि सही व्यवहार क्या है, साथ ही साथ "भविष्य हमें" के लिए एक आसान तरीका प्रदान करता है कि उस व्यवहार की जांच करना सही है।


2

यह एक अच्छा सवाल है, और FWIW मैं अपने दो सेंट में फेंक दूंगा।

लगभग एक साल पहले मैं सेल्सफोर्स में कोडिंग कर रहा था, एक ऐसा प्लेटफॉर्म जिसमें एक अंतर्ग्रहीय तंत्र था जो आपको कोडित करने से पहले जरूरी नहीं कि आपको परीक्षण लिखने के लिए मजबूर करता था , बल्कि आपको सामान्य रूप से परीक्षण लिखने के लिए मजबूर करता था।

इसके काम करने का तरीका यह था कि सिस्टम आपको परीक्षण लिखने के लिए मजबूर करेगा, और यह आपके कोड की उन पंक्तियों की संख्या की गणना करेगा जिन्हें एक प्रतिशत में परीक्षण किया गया था। यदि आपके उत्पादन के दौरान सभी कोड 75% से नीचे गिर गए तो परीक्षण किया गया। Salesforce कोई और काम नहीं करता।

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

बहुत समय आप केवल एक छोटे से टिकट के माध्यम से प्राप्त करने की कोशिश कर रहे थे, और फिर परीक्षण आपके विकास के समय को दोगुना कर देता है, एक विशेषता के लिए जिसे आप अभी जानते हैं

फिर टीडीडी की अजीब अवधारणा हमारे विभाग के माध्यम से बहती है, हमारे डेटाबेस के ठीक नीचे। हमारे आर्किटेक्ट हमारे आईटी विभाग के हर पहलू पर गहन परीक्षण करना चाहते थे। गांड में हल्का दर्द, गांड में और भी ज्यादा दर्द होना।

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

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

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


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

3
@Calphool हम है वास्तव में भाषा में कुछ आसानी से परीक्षण योग्य बातें एकीकृत! हम इसे स्टैटिक टाइपिंग कहते हैं । जंग और भी अधिक कीड़ों के लिए परीक्षण करने के लिए उधार जाँच के साथ इसे आगे ले जाता है । लेकिन अधिकांश परीक्षण उस सटीक वर्ग ("अगर मैं बटन पर क्लिक करता हूं, तो विजेट लाल हो जाता है") के लिए विशिष्ट है - संकलक / आईडीई को कैसे पता चलेगा कि आप परीक्षण करने जा रहे हैं?
user253751

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

1
Salesforce के पास विशेष रूप से परीक्षण सभी गलत हैं: वे जगह में परीक्षण करने के लिए आवश्यक बनाते हैं, लेकिन गुणवत्ता परीक्षण लिखने के लिए इसे हास्यास्पद रूप से कठिन बनाते हैं । यह सिद्धांत में बहुत अच्छा लगता है, लेकिन व्यवहार में यह डेवलपर्स को अपनी आंखों को चम्मच से बाहर निकालना चाहता है।

1

मैं आपके दृष्टिकोण की अनुशंसा नहीं कर सकता।

अगर मैं आपके दृष्टिकोण का उपयोग करता हूं तो यह उदाहरण के लिए होगा जैसे निम्नलिखित (घर का आवेदन है):

  1. मैं अपने परिवार के लिए एक ईंट बनाने वाले के रूप में कुछ ज्ञान के साथ या शुरुआत के रूप में एक घर बनाना शुरू करता हूं।
  2. मैं बच्चे के कमरे, अतिथि कक्ष जैसी आवश्यकताओं को जानता हूं और अपना "प्रोटोटाइप" घर बनाना शुरू करता हूं।
  3. कुछ समय बाद आपके "प्रोटोटाइप" घर में किया जाता है।
  4. मैं यह देखना शुरू करता हूं कि क्या संरचना मैन्युअल रूप से पर्याप्त स्थिर है। इसलिए मैं बहुत सारे वजन उठाता हूं और इसे पहली मंजिल के अलग-अलग कमरों में लाता हूं। यह सुनिश्चित करने के लिए कि जब मैं अपने परिवार के साथ एक कमरे में बैठूं तो छत नहीं टूटेगी। लेकिन यह टूट जाता है और मैं फिर से बनाना शुरू कर देता हूं। पहले सभी द्रव्यमान की सफाई। जब तक यह नया नहीं बन जाता है और तब तक इसे मैन्युअल रूप से परीक्षण करें जब तक कि यह पर्याप्त स्थिर न हो।
  5. मैं अपने परिवार के साथ चलती हूं। सब ठीक है।
  6. एक पतंगे बाद में मेरे चचेरे भाई और माता-पिता हमसे मिलने आ रहे हैं। लेकिन इससे पहले कि वे हमारे घर में प्रवेश कर सकें, उन्हें यह सुनिश्चित करने के लिए एक वास्तुकार और सिविल इंजीनियर को भुगतान करने की आवश्यकता है कि जब हम पहली मंजिल के एक कमरे में बैठते हैं तो छत नहीं टूटती।
  7. आर्किटेक्ट और सिविल इंजीनियर के पास बहुत काम है क्योंकि उनके पास शुरू करने के लिए कुछ भी नहीं है। इसलिए उन्हें मेरे घर में जाने और यह देखने की जरूरत है कि मैं इसे कैसे बनाऊं।
  8. और फिर से यह पर्याप्त स्थिर नहीं है। इसलिए उन्हें पहली मंजिल की जमीन को फिर से तैयार करना होगा।
  9. लेकिन उसके बाद सब कुछ ठीक है और सभी सुरक्षित रूप से मेरे घर में प्रवेश कर सकते हैं।

इससे पहले कि मैं आपके दृष्टिकोण के साथ घर का निर्माण करूँ, आपके दृष्टिकोण में बहुत समय और बहुत ज्ञान है। या यह समय का एक गुच्छा ले लो! जब आवश्यकताएं बदल गई हों, तो अपने कोड के लिए अन्य परीक्षण लिखने देना भी सुंदर नहीं है।

तो एक "प्रोटोटाइप" प्रोग्रामिंग के बिना एक बेहतर तरीका है और रिफैक्टिंग शुरू करने से। एक प्रोटोटाइप प्रोग्रामिंग करने के बजाय "अपने एप्लिकेशन के यूएमएल के साथ एक डिज़ाइन बनाएं जो निम्नानुसार है।

  1. एक UseCase आरेख बनाएँ। आप draw.io का उपयोग शुरू करने के लिए कर सकते हैं ।
  2. व्यवहार निर्धारित करने के लिए अपने UseCases के आधार पर EPK आरेख बनाएं। (अपने आवेदन के BEHAVIOR) रिफैक्टर से कम एक कोडित प्रोटोटाइप के लिए तेजी से। खासकर जब आप एक शुरुआत कर रहे हैं।
  3. एक वर्ग आरेख बनाएँ। (आपके आवेदन की संरचना)
  4. यह निर्धारित करें कि व्यवहार के कार्यान्वयन में आपको कहाँ परेशानी हो सकती है।
  5. यह निर्धारित करने के लिए कि आप इस व्यवहार को कैसे लागू कर सकते हैं यह निर्धारित करने के लिए कोड की 10 या 20 पंक्तियों के साथ एक सरल प्रोटोटाइप लिखें। शुरुआत के लिए अच्छा है। या एक ट्यूटोरियल देखें, वहां से बाहर अन्य उदाहरण अनुप्रयोगों के स्रोत कोड देखें। उन्होंने इसे कैसे हल किया।
  6. कोडिंग शुरू करें अपने UseCase के सफल परीक्षण की मुट्ठी बांधें। यह अलग-अलग तरीकों से किया जा सकता है। सबसे पहले टेस्ट और उस UseCase के लिए आवश्यक सभी संरचना बनाएं। एंटरप्राइज आर्किटेक का उपयोग करते समय संरचना आपके लिए उत्पन्न की जा सकती है। आपके आरेखों के आधार पर। या टेस्ट वायरिंग करते समय संरचना बनाएं। अतः कोई संकलित त्रुटि नहीं दिखाई देती है। यहाँ उल्लेख है कि आपको केवल अपने आवेदन के BEHAVIOR का परीक्षण करने की आवश्यकता है। आपके पास जो UseCases है।
  7. अपने UseCase के व्यवहार को लागू करें।
  8. UseCases सफल होने के बाद अपवादों के लिए टेस्ट लिखना शुरू करें। और यह हमेशा अच्छा लगता है जब आप हरे रंग देखते हैं जब आपके परीक्षण वैध होते हैं;)
  9. और आप कर रहे हैं।

निश्चित रूप से इस दृष्टिकोण को भी यूएमएल में कुछ ज्ञान की आवश्यकता है, लेकिन यह सीखना तेज है। और यह हमेशा अपने IDE में एक वर्ग का नाम बदलने या एक digram में तीर ले जाने के लिए तेज़ है। लेकिन परीक्षण चौखटे का उपयोग सीखना शुरुआत में अधिक थकाऊ होगा। बेस्ट यहां ओपन सोर्स प्रोजेक्ट्स के रन टेस्ट को देखने और देखने के लिए है कि वे कैसे काम करते हैं। लेकिन जब आप एक परीक्षण संचालित आवेदन ave अगले आवेदन बहुत तेज हो जाएगा। और मुझे लगता है कि सब कुछ ठीक काम करता है यह जानना एक अच्छा एहसास है।

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


1

मैं जो कोड लिख रहा हूं वह काम करता है। यह काम करता है क्योंकि मैं इसे मैन्युअल रूप से परीक्षण कर रहा हूं।

क्या आपने थोड़े से बदलाव के बाद अपनी स्थितियों की हर संभव शाखा को मैन्युअल रूप से परीक्षण किया? आपके मैन्युअल परीक्षण के फीडबैक लूप पर कितना समय लगता है। स्वचालित परीक्षण के साथ आपको फीडबैक लूप के कितने करीब है।

स्वचालित परीक्षण (कोई फर्क नहीं पड़ता कि परीक्षण-पहले या नहीं) आपको अपने कोड पर तेजी से प्रतिक्रिया लूप प्रदान करके तेजी से आगे बढ़ता है।

क्या आप सुनिश्चित हैं कि आप छह महीने के बाद मैन्युअल रूप से कुछ स्थिति का परीक्षण करना याद करेंगे - कृपया यह न कहें कि आप परीक्षण करने के लिए सभी महत्वपूर्ण शर्त का दस्तावेजीकरण करेंगे - क्योंकि दस्तावेज / टिप्पणी लिखना लेखन परीक्षण (निष्पादन योग्य प्रलेखन) के बराबर है

  • काम का एक ऊर्ध्वाधर टुकड़ा उठाओ

  • एक कार्यशील प्रोटोटाइप विकसित करें

  • सब कुछ अच्छा और सुव्यवस्थित होने तक रिफ्लेक्टर

और फिर से: रिफैक्टरिंग करते समय क्या आपने मैन्युअल रूप से सभी लॉजिक का परीक्षण किया था जो रिफैक्टिंग से प्रभावित होता है? रिफैक्टरिंग परिवर्तन पर परीक्षण करने में कितना समय लगता है? यदि रीफैक्टरिंग कुछ कोड को तोड़ता है तो आपको ब्रेक का कारण खोजने में कितना समय लगता है?

  • मेरे द्वारा लिखे गए खूबसूरती से ठोस और परीक्षण योग्य कोड की सराहना करें।

सुंदर और साफ कोड आपको बहुत पसंद आया। आपका कोड आपके लिए साफ और उचित हो सकता है। यह जांचने का सबसे अच्छा तरीका है कि क्या आपका कोड वास्तव में पठनीय, समझने योग्य और परीक्षण योग्य है, अन्य डेवलपर्स द्वारा किए गए परीक्षण और कोड समीक्षाएं हैं।

आपने अपना रास्ता बहुत ही उत्पादक पाया क्योंकि आप केवल कोड के साथ काम करने वाले डेवलपर हैं, और, मुझे लगता है, क्योंकि आप केवल इस परियोजना में काम करना शुरू कर रहे हैं (आप इस परियोजना पर कितना पुराना काम कर रहे हैं? 6 - 8 महीने?)।
आपको अभी भी सब कुछ याद है जो आपने लिखा था और आप संभावित समस्याओं का कारण पहचान सकते हैं। मुझे पूरा यकीन है कि आप अपने प्रोजेक्ट के 2 - 3 साल बाद शुरू से टेस्ट लिखना शुरू कर देंगे - क्योंकि आप सुनिश्चित करना चाहते हैं कि आप कुछ भी न भूलें।


0

यदि आप कभी गलती नहीं करते हैं तो आपको वास्तव में परीक्षणों की आवश्यकता नहीं है। अधिकांश डेवलपर्स गलती करते हैं, लेकिन अगर आप कभी नहीं करते हैं, और आप आश्वस्त हैं कि आप भविष्य में कभी भी गलतियां नहीं करेंगे (और आप परियोजना पर केवल एक ही हैं), समय लेखन परीक्षणों को बर्बाद करने का कोई कारण नहीं है।

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

बेशक अच्छी वास्तुकला, ठोस सिद्धांतों आदि को ऐसा होने से रोकना चाहिए, लेकिन अधिकांश डेवलपर्स सही नहीं हैं, और यही कारण है कि सिस्टम में परीक्षण मूल्यवान हैं।


बेशक अच्छी वास्तुकला, ठोस सिद्धांतों आदि को ऐसा होने से रोकना चाहिए । कॉम्प्लेक्स सिस्टम में ऐसे हिस्से होते हैं जो अन्य भागों को प्रभावित करते हैं, बस यह कैसा है। जैसे में ANTLR व्याकरण को संशोधित करने Rubberduck आसानी से संशोधित इरादा हिस्सा काम पूरी तरह से कर सकते हैं, जबकि 45 अन्य सुविधाओं को तोड़ने। पूरी तरह से परीक्षण के बिना, पता करने का कोई तरीका नहीं है, और आपको हर बार मैन्युअल रूप से सभी मामलों का परीक्षण करना चाहते हैं। यदि मैं रिज़ॉल्वर में कुछ बदल देता हूं और 987 परीक्षण टूट जाते हैं, तो मुझे पता है कि मैंने कुछ गलत किया और इसका क्या प्रभाव पड़ा।
मैथ्यू गुइंडन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.