क्या परियोजना के अंत में बग को ठीक करना काफी महंगा है?


21

में एंड्रयू सूखी घास से एक ब्लॉग पोस्ट , निम्नलिखित स्वयंसिद्ध समान समझा जाता था:

परियोजना के अंत में बग को ठीक करने के लिए काफी अधिक लागत आती है जो परियोजना में पहले उसी बग को ठीक करने के लिए करता है।

हालाँकि, यह निश्चित नहीं लगता है, विशेष रूप से कम गलत पर एक ब्लॉग पोस्ट पढ़ने के बाद , और जो डेटा मैंने इसे वापस देखा है वह बहुत पुराना है।

क्या यह आज भी स्वयंसिद्ध है?


@StefanHendriks Morendil से लेख से जुड़ी आपकी टिप्पणियों में वह सब कुछ शामिल है जो आप पूछ सकते हैं; IMHO। बहुत अच्छी जानकारी है।
हारून मैकाइवर

@AaronMcIver मेरा इरादा इस बारे में और लोगों को जानना है। जैसे शब्द को फैलाना और वास्तविक डेटा को बाहर निकालने की संभावना बढ़ाना। मैं एक वास्तविक चर्चा की खोज नहीं करता हूं; महान लोगों को लेख पर आयोजित किया जा रहा है (जैसा कि आपने भी पता किया है :))।
स्टीफन हेंड्रिक्स

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

यद्यपि यह निश्चित रूप से प्रोग्रामिंग के साथ करना है, प्रश्न की प्रकृति वास्तव में critics.stackexchange.com पर इसे और अधिक उपयुक्त बना सकती है।
स्ट्रिपिंगवर्यर

जवाबों:


16

मेरे द्वारा देखा गया एकमात्र कठिन डेटा है बोहेम और पापियाको, अंडरस्टैंडिंग और सॉफ्टवेयर लागतों को नियंत्रित करना

यह 1988 तक वापस उपजा और लगभग 80 सॉफ्टवेयर परियोजनाओं का अध्ययन था। उन्होंने निष्कर्ष निकाला कि देर से और जल्दी सही किए गए निर्णय की लागत 50-200 गुना हो सकती है यदि इसे जल्दी ठीक किया जाता तो क्या होता। लेकिन जिस तरह के शुरुआती फैसले की वे बात कर रहे हैं वह कौन से ओएस पर चलना है और किस भाषा और डेटाबेस का उपयोग करना है।

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

चरम में, हम जानते हैं कि यदि हम उत्पादन में जाने से ठीक पहले आवश्यकताओं में विफलता को पकड़ लेते हैं, तो यह बहुत अधिक काम का कारण बनता है और परियोजना को विलंबित या वास्तव में रद्द कर दिया जाता है, अगर यह किसी काम से पहले पकड़ा गया था, तो हम 'ठीक हो गया।

संपादित करें: डॉक्टर ब्राउन ने अपनी टिप्पणी में एक अच्छी बात कही।

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

बदले में, हमारे मालिक हमारी शिकायतों पर हंसते थे क्योंकि यह बहुत पहले नहीं था जब वे सर्वर रूम में हाथ से सॉर्ट किए गए पंच कार्ड का एक बॉक्स ले जाते थे और इसे एक दिन के लिए वहां छोड़ देते थे।

तो यह निश्चित रूप से अधिक सच था तो अब की तुलना में है।

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

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


3
+1। मुझे लगता है कि किसी को यह कहना चाहिए कि बोहेम का अनुसंधान ऐसे समय में किया गया है, जहां बगफिक्स रिलीज के निर्माण और तैनाती की लागत आज की तुलना में बहुत अधिक थी।
डॉक ब्राउन

@DocBrown: अच्छी बात है। जोड़ा गया। साथ में एक और टेढ़ा।
पीडीआर

वास्तव में संदर्भ के लिए +1, विज़ुअलाइज़ेशन के लिए +1 (बहुत बुरा मैं केवल एक बिंदु दे सकता हूं।) शानदार जवाब, धन्यवाद!
स्टेफन हेंड्रिक्स

15

जब मैं किसी भी कठिन डेटा या अन्य सबूत एक पर, इस दावे के समर्थन में के बारे में पता नहीं कर रहा हूँ न्यूनतम , मैं यह आम बात है तय करेंगे।

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

इसके अलावा, यदि आप कीड़े को जल्दी ठीक कर रहे हैं, तो कार्यान्वयन अभी भी डेवलपर के दिमाग में ताज़ा है। किसी भी दिए गए प्रोजेक्ट की लंबाई के आधार पर, यदि आप अंत में बग को ठीक कर रहे हैं, तो डेवलपर को यह पता लगाने में समय बिताना होगा कि उन्होंने क्या लिखा है और (शायद) सबसिस्टम कि उनका कोड काम पर कैसे निर्भर करता है। इस = $ को पुनः सीखने में समय व्यतीत हुआ।


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

@StefanHendriks: हम दोनों प्रयासों की मात्रा के बारे में बात कर रहे हैं और साथ ही दावा किए गए फ़िक्सेस द्वारा किए गए नए कीड़े भी हैं। आपको संभवतः वास्तविक डेटा प्राप्त करने के लिए प्रोजेक्ट पोस्ट मॉर्टेमेज़ (जो दोनों विधियों को नियोजित किया गया है) में खोदना होगा।
डेमियन ब्रेख्त

2
@AaronMcIver: लेख का मेरा तरीका यह नहीं है कि कौन सा तरीका बेहतर है, बल्कि यह कि बाद के रिपोर्टों में दावे और गलतफहमी को दूर करने के लिए इस्तेमाल किए गए शोध और कठिन आंकड़े। हालांकि मेरा जवाब सार्वजनिक डेटा पर आधारित नहीं है, यह अत्यधिक जटिल प्रणालियों से निपटने के 10+ साल के पेशेवर अनुभव पर आधारित है।
डेमियन ब्रेख्त

1
BTW मैं असहमत हूं कि CSS परिवर्तन इससे ग्रस्त नहीं हैं। एक बार लेआउट संबंधी समस्या को ठीक करने का प्रयास करें, जब आपके पास अन्य सभी सामान पिक्सेल सही हों और आप पाएंगे कि आपको बहुत सारी चीजें
एंड्रिया

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

12

मुझे संदेह है कि यह मापने के लिए वैज्ञानिक रूप से कठोर तरीके से आना संभव है - इसमें अभी भी कई अन्य कारक शामिल हैं, और कोई भी दो मामले तुलनात्मक नहीं हैं जो केस स्टडी से अधिक हैं। तार्किक सोच को आपको एक लंबा रास्ता तय करना चाहिए। कुछ तर्क:

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

+1। बहुत बढ़िया जवाब। कोड और पेस्ट करने वाला कोड जिसमें बग्स पर निर्भर मॉड्यूल के आधार पर अधिक बग उत्पन्न करते हैं।
कार्तिक श्रीनिवासन

2

यह सिस्टम इंजीनियरिंग से मूल स्वीकृत सामान है - और यह तकनीकी विकास के किसी भी रूप पर लागू होता है (जैसे कि पुल, मिसाइल, युद्धपोत या सॉफ्टवेयर का निर्माण)।

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

विचार की कल्पना करने के बिंदु पर तय करने के लिए कुछ लागत $ 10 है ...

यदि आपको किसी विशेष विनिर्देश को अद्यतन करने की आवश्यकता है, तो लगभग $ 100 का खर्च आएगा ...।

या लगभग 1000 डॉलर की लागत अगर कुछ लागू किया गया था और आपको उस बिंदु पर बदलाव करने की ज़रूरत है (और युक्ति को अद्यतन करें, और अनुमोदन प्राप्त करें और इसी तरह) लेकिन यह किसी प्रकार की औपचारिक स्वीकृति के माध्यम से नहीं गया था / परीक्षण को बेचना

या लगभग 10000 डॉलर की लागत अगर कुछ लागू किया गया था और ग्राहक को स्वीकार किया गया था, और आपको उस बिंदु पर परिवर्तन करने की आवश्यकता है (और कल्पना को अद्यतन करें, और अनुमोदन प्राप्त करें, और ग्राहक स्वीकृति और योग्यता को पुनः परीक्षण करें और इसी तरह से)

और तैनाती / रोल आउट / सेवा में डालने के बाद लागत फिर से अधिक है।

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

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


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

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

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

यह वेब अनुप्रयोगों के लिए मामला हो सकता है लेकिन यह संपूर्ण ब्रह्मांड नहीं है। वाशिंग मशीन के बारे में क्या? कारें? मिसाइल? पीसी ऑपरेटिंग सिस्टम? बिजली की स्टेशनों? सीमेंट प्लांट चलाने वाले पीएलसी? पर और सूची में और पर चला जाता है।
जल्दी से

2

मेरे पास कठिन डेटा या तथ्यों तक पहुंच नहीं है, इसलिए मैं केवल आईटी में मेरे पिछले 20 वर्षों से प्राप्त किए गए उपाख्यानों का अवलोकन कर सकता हूं।

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

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

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

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

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

लेकिन जैसा कि मैं कहता हूं, यह कठिन डेटा-समर्थित सबूत नहीं है, बस पिछले कुछ वर्षों की मेरी टिप्पणियों, और मेरे पेट ने मुझे बताया कि आने के लिए और अधिक ग्राउंड-शेकिंग ज्ञान होगा जो हमारे काम करने के तरीके में सुधार करेगा।


1

प्रारंभिक कीड़े सिस्टम के अन्य भागों में प्रचार करेंगे ताकि जब आप बग को ठीक करें तो आपको सिस्टम के कुछ हिस्सों को फिर से लिखने के लिए मजबूर किया जा सके जो बग पर ही निर्भर थे।

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

यह उतना ही सरल है और सबूत के लिए कुछ भी नहीं है।

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


हाँ यह सब समझ में आता है। हालांकि, मुझे आश्चर्य है कि क्या यह बाद में फिक्सिंग से काफी अलग है। हां, आपको सामान को फिर से सीखने की जरूरत है। हालांकि, शायद द्वारा नहीं जारी पहले आप लागत यह इस समस्या का समाधान नहीं होगा और अधिक से अधिक पैसे खो दिया है। यह तय करने के लिए इस मुद्दे को सस्ता या महंगा बना देगा? यहां तक ​​कि जब यह कम काम है क्योंकि यह शुरुआत में था?
स्टेफन हेंड्रिक्स

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

>> ... आपको सामान को फिर से सीखने की जरूरत है ... विशेष रूप से एज मामले इस मुश्किल और गैर-तुच्छ बनाते हैं। जब तक आपके पास एक संपूर्ण, सही, और बनाए रखा विनिर्देश नहीं होता है , तत्काल के बाहर की बातचीत जल्दी से भूल जाते हैं ।
डेव

1

ठीक है, मैं शायद आपको निश्चित प्रमाण नहीं दे सकता, जो आप पूछ रहे हैं, लेकिन मैं अपने काम से हाल ही की घटना से संबंधित हो सकता हूं।

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

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

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


1

यदि आप रिलीज के बाद बग को ठीक करते हैं, तो आपके पास बग को खोजने और ठीक करने की लागत है - जो पोस्ट रिलीज करने के लिए अधिक समय / लागत ले सकता है या नहीं ले सकता है। हालाँकि आपके पास एकीकरण परीक्षण, प्रतिगमन परीक्षण, UA परीक्षण, रिलीज़ गतिविधियाँ, आदि का एक दौर है, जिनका हिसाब देना होगा। जब तक बग फिक्स कई अन्य सुधारों या एक संस्करण अद्यतन के साथ नहीं जाता है, तो आपको परीक्षण और रिलीज की गतिविधियों के लिए अतिरिक्त खर्च होगा जो प्रारंभिक रिलीज में फिक्स को शामिल करने से बचा जाएगा - क्योंकि ये लागत कई संख्या में साझा की जाएगी। फिक्स / अद्यतन / सुविधाओं।

लागत पर भी विचार करें कि बग किस कारण से उपयोग में आएगा, यदि यह सिर्फ कॉस्मेटिक है, तो यह शायद कोई फर्क नहीं पड़ता है, लेकिन एक फ़ंक्शन या प्रदर्शन बग समर्थन गतिविधियों या कम उत्पादकता या गलत गणना के साथ लागत पैदा कर सकता है।


1

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

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

यदि एक बग जंगली में बच जाता है, तो लागत में एक कदमवार उछाल होता है ...... सॉफ्टवेयर के जारी होने से पहले या बाद में "परियोजना का अंत" होता है?


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

आपके द्वारा बताए गए कीड़े जल्दी नहीं पाए गए और इसलिए उन्हें जल्दी ठीक नहीं किया गया।

@ Thorbjørn आप वास्तव में सही हैं - हालांकि हम जल्दी सम्मिलित किए गए दोषों का पता नहीं लगाते हैं (द एरियन रॉकेट के मामले में, परियोजना शुरू होने से पहले ही बग को सम्मिलित किया गया था, क्योंकि उन्होंने मौजूदा कोड का पुन: उपयोग किया था।) लागत सम्मिलन और तैनात किए गए सुधार के बीच के समय के लिए आनुपातिक है, जब यह पाया जाता है या तय किया जाता है तो कुछ भी नहीं करना है (अधिकांश डेवलपर्स इसे एक बार तय करते हैं कि पैच कोड आधार में है। एक दोष तब तक तय नहीं किया जाता है जब तक कि अंतिम उपयोगकर्ता इसे स्थापित नहीं करते हैं। )। यह सब केवल IMHO है - हालांकि मेरे पास इसका समर्थन करने के लिए कोई सबूत नहीं है।
मटकाज

1

मैंने एक बार एक लेख पढ़ा था जिसमें दो दिलचस्प बिंदु थे (दुर्भाग्य से मेरे पास जो संदर्भ थे वे लंबे समय से चले गए हैं, इसलिए मुझे बस यहां पोस्ट करना होगा)। उन्होंने जो पहला बिंदु बनाया, वह यह था कि आवश्यकताओं के विनिर्देशन में लगभग 50% त्रुटियों को पेश किया गया था और यह कि सभी त्रुटियों का लगभग 90% UAT या सिस्टम परीक्षणों के दौरान पाया गया था।

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

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


1

कोई सांख्यिकीय डेटा नहीं, लेकिन व्यक्तिगत अनुभव:

मैं जिस रॉकेट मोटर कंट्रोल कोड पर काम कर रहा था, उसकी एक लाइन थी powerCutoff = someCondition && debugOptions.cutoffIsAllowed;। डिफ़ॉल्ट विकल्प को किसी कटऑफ की अनुमति नहीं थी। 'फाइनल' बिल्ड सभी डिबग विकल्पों को हटाने के लिए था, इसलिए लाइन को संशोधित किया गया powerCutoff = someCondition;

क्या आपने कोड समीक्षा के दौरान बग को पकड़ा था? हमने नहीं किया। पहली बार ट्रिगर की स्थिति परीक्षण में हुई थी, जो पहली उड़ान से कुछ महीने पहले अप्रत्याशित कटऑफ थी।

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

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


0

अफसोस की बात है, कई चीजों की तरह, यह निर्भर करता है।

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

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

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.