मूल विकास बनाम कीड़े पर किस समय खर्च किया जाना चाहिए? [बन्द है]


26

यह सवाल थोड़ा सार है लेकिन मुझे उम्मीद है कि कोई मुझे सही दिशा में ले जा सकता है।

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

उदाहरण के लिए, यदि प्रोजेक्ट A को पूरा होने में 40 घंटे लगते हैं और अतिरिक्त 10 फिक्सिंग बग्स होते हैं तो इस प्रोजेक्ट में 4: 1 अनुपात होगा।

यदि किसी अन्य प्रोजेक्ट (B) को पूरा होने में 10 घंटे लगते हैं, लेकिन कीड़े पर एक और 8 तो इसका 5: 4 अनुपात होगा।

क्या यह एक प्रलेखित / शोधित अवधारणा है?

अद्यतन करें

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


यह विकास के प्रयासों की गुणवत्ता पर निर्भर करता है। अधिक गुणवत्ता कम बग फिक्सिंग का नेतृत्व करती है।
थॉमसएक्स

जवाबों:


16

दोष-निर्धारण के लिए आवंटित कुल क्षमता का संतुलन प्रतिशत दोष इंजेक्शन दर के बराबर है

कई कारक इस दर को प्रभावित कर सकते हैं, उनमें से, ज़ाहिर है: टीम किस तरह का उत्पाद विकसित कर रही है, वे किन तकनीकों और तकनीकी प्रथाओं का उपयोग करते हैं, टीम के कौशल स्तर, कंपनी की संस्कृति, आदि।

टीम बी को ध्यान में रखते हुए, यदि वे अपने द्वारा पूरी की जाने वाली प्रत्येक 10 इकाइयों के लिए औसत 8 इकाइयों का निर्माण करते हैं, तो उन 8 इकाइयों के काम करने से नए 6.4 यूनिट्स का निर्माण होगा। हम कुल प्रयास का अनुमान लगा सकते हैं कि आखिरकार उन्हें ज्यामितीय प्रगति के योग के रूप में खर्च करना होगा:

10 + 8 + 6.4 + 5.12 + ...

समय के साथ बगों की संख्या में तेजी से कमी आएगी, लेकिन टीम बी में उनके घटक में ऐसा गुणांक है कि यह बहुत धीरे-धीरे शून्य हो जाएगा। दरअसल, उपरोक्त श्रृंखला में पहले तीन शब्दों का योग केवल 24.4 है; पहले पाँच में, 33.6; पहले 10, 45; पूरी श्रृंखला, 50. तो, टीम बी सारांश: दोष इंजेक्शन दर, 0.8; सुविधा विकास, 10/50 = 20%; दोष-निर्धारण, 80%। 20/80 उनकी स्थायी क्षमता आवंटन है।

इसके विपरीत, टीम ए ज्यादा बेहतर आकार में है। उनकी प्रगति इस तरह दिखती है:

40 + 10 + 2.5 + 0.625 + ...

इस श्रृंखला का योग 53 1/3 है, इसलिए टीम ए की सुविधा विकास आवंटन 40 / (53 1/3) = 75% है और दोष-निर्धारण आवंटन 25% है, जो कि उनके दोष इंजेक्शन दर 10/40 = 0.25 से मेल खाता है ।

दरअसल, पहले तीन के बाद टीम ए की श्रृंखला के सभी शब्द लापरवाही से छोटे हैं। व्यावहारिक अर्थों में इसका मतलब यह है कि टीम ए शायद रखरखाव के एक जोड़े के साथ अपने सभी कीड़े को स्क्वाश कर सकती है, दूसरा रिलीज काफी छोटा है। इससे एक भ्रम भी पैदा होता है कि कोई भी टीम ऐसा कर सकती है। लेकिन टीम बी नहीं।

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

"... 2000 में ... उत्तर अमेरिकी टीमों के लिए सॉफ्टवेयर की गुणवत्ता को मापा ... प्रति फ़ंक्शन 6 बिंदु से कम से कम 3 प्रति 100 फ़ंक्शन बिंदुओं तक कम, 200 से 1. की सीमा । मिडपॉइंट लगभग 1 दोष प्रति है 0.6 से 1.0 फंक्शन पॉइंट्स। इसका तात्पर्य यह है कि टीमों के लिए 90 प्रतिशत से अधिक खर्च करने के लिए आम है कि वे अपने प्रयासों के दोषों को ठीक कर सकें। " ।

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

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

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

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


8

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


8

आपको बग पर समय व्यतीत करना चाहिए, यदि आप जो तय करते हैं उससे आप जो निवेश करते हैं उससे अधिक है।

निम्नलिखित जैसे एक मैट्रिक्स का उपयोग करें (बग को ठीक करने के लिए क्षैतिज समय, ऊर्ध्वाधर - बग का प्रकार - उपयोगकर्ताओं पर प्रभाव)

              | Few hours | Many hours
--------------+-----------+-------------------------
Minor problem | Might fix | Fix only if time permits
--------------+-----------+-------------------------
Major problem | Fix       | Fix

समस्याओं का उदाहरण:

              | Few hours                            | Many hours
--------------+--------------------------------------+---------------------------------
              | Window moves 1px every 10            | Windows is painted incorrectly 
Minor problem | times when you open the application. | every 100th time the app is open.
              | Fix is: handle window resize event   | Fix: Change the graphical engine.
--------------+--------------------------------------+---------------------------------
Major problem | Application crashes when opening     | Poor performance when >100 users 
              | SQL connection.                      | are connected (unusable app)
              | Fix: Fix invalid query + add nice    | Fix: change architecture + DB
              | message                              |

मैट्रिक्स गंभीरता, प्रयास, जोखिम आदि के विभिन्न स्तरों के साथ अधिक जटिल हो सकता है

आप प्रत्येक बग के लिए एक रैंक भी बना सकते हैं और उन्हें रैंकिंग के आधार पर ठीक कर सकते हैं। कुछ इस तरह:

Bug priority = Risk x Severity x Effort

* कुछ ऑपरेंड के लिए (1-x) हो सकता है, आप किस पैमाने पर निर्भर करते हैं :)

इसलिए, अपने प्रश्न का उत्तर देने के लिए: बग्स के प्रकार, उपलब्ध समय / बजट, आदि पर निर्भर करता है।


अब यह सोचकर लागू होता है!
मार्क सी

3

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

उदाहरण के लिए, एक जलप्रपात मॉडल पर आप पहले परीक्षण चरण में पहली बग को ठीक से सेट कर सकते हैं, लेकिन एक फुर्तीले वातावरण में "यहां से, हम कीड़े को सही कर रहे हैं" कहते हुए एक पंक्ति को उठाना मुश्किल हो सकता है, (जैसे) और मेरे लिए यह एक बग के रूप में एक सुविधा परिवर्तन की गिनती करना उचित नहीं है)

अनुभव से, मैं कहता हूं कि यह ऐसा कुछ है जो हमेशा से कम है, और बहुत आसानी से "मूल परियोजना" की तुलना में घंटों की राशि खर्च कर सकता है।


बधाई हो! इसके अलावा, आपकी प्रोफ़ाइल तस्वीर में कौन आदमी है? यह निकोला टेस्ला नहीं है ।
मार्क सी

Haha, नहीं, यह Orville Gibson siminoff.net/pages/gibson_background.html
Khelben

3

वास्तव में सही उत्तर बग फिक्स पर शून्य घंटे होगा क्योंकि आपका कोड सही है। :-)

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


मुझे कई बार उस मीट्रिक के लिए कहा गया है। यह बहुत बेहतर प्रबंधन है कि आप उनसे अनुपात के लिए पूछें मान लें कि अनुपात 1: 0 है।
darreljnz

2

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


1

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

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


1

महत्वपूर्ण सोफ़वेयर पर, ए 1: 1 अनुपात असामान्य नहीं है। अकेले यूनिट परीक्षण के लिए, मैंने संकेतक को कोड के प्रत्येक 10 लाइनों के लिए यूनिट परीक्षण के 1 दिन का उल्लेख किया है।


1

मुझे लगता है कि यह सवाल पक्षपाती है: यह इस बात से शुरू होता है कि बग को ठीक करना नई कार्यक्षमता विकसित करने के समान है । यह मामला नहीं है।

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

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

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

इसलिए "बग पर समय बिताने" के बारे में बात करने के बजाय, आपको "परीक्षणों पर खर्च किया गया समय" (एकीकरण परीक्षण, उपयोगकर्ता स्वीकृति परीक्षण ...) के बारे में बात करनी चाहिए


1

मुझे लगता है कि आप सही हैं - आप कारकों को प्रभावित करने की संख्या के कारण कोई सार्थक मीट्रिक प्राप्त नहीं करने जा रहे हैं।

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

एक अवलोकन यह है कि कोड का विकास और कोड का परीक्षण / बग फिक्सिंग दो अलग-अलग चरण नहीं होने चाहिए। यदि आप बग फिक्सिंग की "लागत" विकसित करते हैं तो परीक्षण कम होता है।


0

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

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