मैं इसे इस तथ्य के साथ पेश करने जा रहा हूं कि मैं जो कुछ भी खोज रहा हूं, वह 1970 और 1980 के दशक की शुरुआत से आता है। इस समय के दौरान, अनुक्रमिक प्रक्रिया मॉडल पुनरावृत्ति और / या वृद्धिशील दृष्टिकोण (सर्पिल मॉडल या फुर्तीली विधियों) की तुलना में अधिक सामान्य थे। इस काम का ज्यादातर हिस्सा इन अनुक्रमिक मॉडल पर बनाया गया है। हालाँकि, मुझे नहीं लगता है कि यह रिश्ते को नष्ट कर देता है, लेकिन पुनरावृत्तियों / वृद्धिशील दृष्टिकोणों में से एक लाभ सुविधाओं को जारी करना है (एक आवेदन का एक पूरा ऊर्ध्वाधर टुकड़ा) जल्दी और सही समस्याओं में यह निर्भरता है कि प्रत्येक चरण में इंजेक्शन और जटिलता है। ऊंचा है।
मैंने अभी-अभी सॉफ्टवेयर इंजीनियरिंग इकोनॉमिक्स की अपनी कॉपी निकाली और अध्याय 4 में इस चार्ट के पीछे के डेटा का संदर्भ पाया। वह एमई फगन ( आईईईई , पीडीएफ यूएमडी से ), ईबी द्वारा "डिजाइन और कोड इंस्पेक्शन इन प्रोग्राम डेवलपमेंट को कम करता है" डैली की "सॉफ्टवेयर इंजीनियरिंग का प्रबंधन", हम स्टीफेंसन के "सुरक्षा प्रणाली के सॉफ्टवेयर विकास में प्रयुक्त संसाधन का विश्लेषण" ( एसीएम ), और "कई टीआरडब्ल्यू परियोजनाएं"।
... सॉफ्टवेयर त्रुटियों को सुधारने की सापेक्ष लागत (या अन्य सॉफ़्टवेयर परिवर्तन करना) चरण के एक फ़ंक्शन के रूप में जिसमें सुधार या परिवर्तन किए जाते हैं। यदि सॉफ़्टवेयर आवश्यकताओं में त्रुटि का पता लगाया जाता है और योजनाओं और आवश्यकताओं के चरण के दौरान इसे ठीक किया जाता है, तो इसका सुधार आवश्यकताओं के विनिर्देश को अद्यतन करने का एक अपेक्षाकृत सरल मामला है। यदि रखरखाव चरण तक एक ही त्रुटि को ठीक नहीं किया जाता है, तो सुधार में विनिर्देशों, कोड, उपयोगकर्ता और रखरखाव मैनुअल और प्रशिक्षण सामग्री की एक बड़ी सूची शामिल होती है।
इसके अलावा, देर से सुधार में बहुत अधिक औपचारिक परिवर्तन अनुमोदन और नियंत्रण प्रक्रिया शामिल है, और सुधार को अमान्य करने के लिए एक अधिक व्यापक गतिविधि। ये कारक आवश्यकताओं की तुलना में बड़ी परियोजनाओं पर रखरखाव चरण में सही करने के लिए आम तौर पर त्रुटि को 100 गुना अधिक महंगा बनाने के लिए गठबंधन करते हैं।
बोहेम ने दो छोटे, कम औपचारिक परियोजनाओं को भी देखा और लागत में वृद्धि देखी, लेकिन बड़ी परियोजनाओं में पहचाने गए 100 गुना से भी कम महत्वपूर्ण है। चार्ट को देखते हुए, आवश्यकताओं के चरण की तुलना में सिस्टम चालू होने के बाद आवश्यकताओं की कमी को ठीक करने के लिए अंतर 4 गुना अधिक प्रतीत होता है। उन्होंने इसके लिए उन मदों की छोटी सूची को जिम्मेदार ठहराया, जिनमें परियोजना शामिल है और कम औपचारिकता है जो सरल निश्चित रूप से तेजी से लागू करने की क्षमता का नेतृत्व करती है।
सॉफ्टवेयर इंजीनियरिंग इकोनॉमिक्स में बोहेम पर आधारित, कोड कम्प्लीट में टेबल बल्कि फूला हुआ है (श्रेणियों का कम अंत अक्सर बहुत अधिक होता है)। चरण के भीतर किसी भी परिवर्तन करने की लागत वास्तव में है 1. सॉफ्टवेयर इंजीनियरिंग अर्थशास्त्र में चित्रा 4-2 से बाहर निकालना, एक आवश्यकता परिवर्तन वास्तुकला में 1.5-2.5 गुना, कोडिंग में 2.5-10, परीक्षण में 4-20 और 4-4 होना चाहिए। रखरखाव में 100। राशि परियोजना के आकार और जटिलता के साथ-साथ उपयोग की जाने वाली प्रक्रिया की औपचारिकता पर निर्भर करती है।
बैरी बोहम के अपेंडिक्स ई में और रिचर्ड टर्नर की संतुलन क्षमता और अनुशासन में परिवर्तन की लागत के बारे में अनुभवजन्य निष्कर्षों पर एक छोटा सा खंड शामिल है।
प्रारंभिक पैराग्राफ केंट बेक के चरम प्रोग्रामिंग समझाया, बेक के हवाले से उद्धृत करते हैं। इसमें कहा गया है कि यदि समय के साथ परिवर्तनों की लागत धीरे-धीरे बढ़ी, तो निर्णय यथासंभव देर से किए जाएंगे और केवल उसी चीज की आवश्यकता होगी जो कार्यान्वित की जाएगी। यह "सपाट वक्र" के रूप में जाना जाता है और यह वही है जो चरम प्रोग्रामिंग करता है। हालाँकि, पिछले साहित्य में पाया गया कि "खड़ी वक्र", छोटी प्रणालियों (<5 KSLOC) में 5: 1 का परिवर्तन है और बड़े सिस्टम में 100: 1 का परिवर्तन है।
यह खंड मैरीलैंड के सेंटर फॉर एम्पैरिकली बेस्ड सॉफ्टवेयर इंजीनियरिंग (नेशनल साइंस फाउंडेशन द्वारा प्रायोजित) का हवाला देता है। उन्होंने उपलब्ध साहित्य की खोज की और पाया कि परिणाम 100: 1 अनुपात की पुष्टि करने के लिए गए, कुछ परिणामों के साथ 70: 1 से 125: 1 की सीमा का संकेत मिलता है। दुर्भाग्य से, ये आम तौर पर "बड़े डिज़ाइन अप फ्रंट" प्रोजेक्ट थे और क्रमबद्ध तरीके से प्रबंधित होते थे।
चरम प्रोग्रामिंग का उपयोग करके "छोटे वाणिज्यिक जावा प्रोजेक्ट्स" के नमूने हैं। प्रत्येक स्टोरी के लिए, एरर फिक्सिंग, नए डिज़ाइन और रीफैक्टरिंग में प्रयास की मात्रा को ट्रैक किया गया था। डेटा दिखाता है कि जैसे-जैसे सिस्टम विकसित होता है (अधिक उपयोगकर्ता कहानियां लागू की जाती हैं), औसत प्रयास एक गैर-तुच्छ दर में वृद्धि करता है। रिफैक्टरिंग में प्रयास लगभग 5% बढ़ जाता है और प्रयास फिक्सिंग के प्रयासों में लगभग 4% की वृद्धि होती है।
मैं जो सीख रहा हूं, वह यह है कि सिस्टम जटिलता जरूरत के प्रयास में एक महान भूमिका निभाता है। सिस्टम के माध्यम से ऊर्ध्वाधर स्लाइस का निर्माण करके, आप ढेर में जोड़ने के बजाय धीरे-धीरे जटिलता को जोड़कर वक्र की दर को धीमा कर देते हैं। एक अत्यंत जटिल वास्तुकला के बाद आवश्यकताओं की जटिलता के द्रव्यमान से निपटने के बजाय, एक अत्यंत जटिल कार्यान्वयन के बाद, और इसी तरह, आप बहुत सरलता से शुरू करते हैं और जोड़ते हैं।
इसे ठीक करने की लागत पर क्या प्रभाव पड़ता है? अंत में, शायद ज्यादा नहीं। हालांकि, इसमें जटिलता (तकनीकी ऋण के प्रबंधन के माध्यम से) पर अधिक नियंत्रण के लिए अनुमति देने के फायदे हैं। इसके अलावा, अक्सर सुपुर्दगी से जुड़े अक्सर का मतलब है कि परियोजना जल्द ही समाप्त हो सकती है - "सिस्टम" को वितरित करने के बजाय, टुकड़ों को तब तक वितरित किया जाता है जब तक कि व्यवसाय की आवश्यकताएं पूरी नहीं होती हैं या बहुत तेजी से बदल गई हैं कि एक नई प्रणाली (और इसलिए एक नई परियोजना) जरूरत है।
सॉफ्टवेयर क्वालिटी इंजीनियरिंग में स्टीफन कान के मेट्रिक्स एंड मॉडल्स में चरण 6 दोष की लागत प्रभावशीलता के बारे में अध्याय 6 में एक खंड है।
उन्होंने फगन के 1976 के पेपर (सॉफ्टवेयर इंजीनियरिंग अर्थशास्त्र में भी उद्धृत) का हवाला देते हुए कहा कि उच्च स्तर के डिजाइन (सिस्टम आर्किटेक्चर), निम्न स्तर के डिजाइन (विस्तृत डिजाइन) में किया गया, और कार्यान्वयन 10 से 100 गुना कम महंगा हो सकता है। घटक और सिस्टम स्तर परीक्षण के दौरान किए गए कार्य की तुलना में।
वह 1982 और 1984 के दो प्रकाशनों का भी हवाला देते हैं, जो फ्रीडमैन और वेनबर्ग द्वारा बड़े सिस्टम पर चर्चा करते हैं। पहला "हैंडबुक ऑफ़ वॉकथ्रूज़, इंस्पेक्शन एंड टेक्निकल रिव्यू" और दूसरा "रिव्यू, वॉकथ्रूज़ और इंस्पिरेशन" है। विकास चक्र में शुरुआती समीक्षाओं के आवेदन से 10. के कारक द्वारा परीक्षण चरणों तक पहुंचने वाली त्रुटियों की संख्या को कम किया जा सकता है। दोषों की संख्या में कमी से परीक्षण लागत 50% से 80% तक कम हो जाती है। मुझे अध्ययनों को अधिक विस्तार से पढ़ना होगा, लेकिन ऐसा प्रतीत होता है कि लागत में दोषों को ढूंढना और उन्हें ठीक करना भी शामिल है।
1983 में रेमस द्वारा "इंस्पेक्ट्स / रिव्यू के व्यू में इंटीग्रेटेड सॉफ्टवेयर वैलिडेशन" के एक अध्ययन में कैलिफोर्निया में आईबीएम की सांता टेरेसा प्रयोगशाला के डेटा का उपयोग करके विभिन्न चरणों में दोषों को दूर करने, विशेष रूप से डिजाइन / कोड निरीक्षण, परीक्षण और रखरखाव का अध्ययन किया गया। उद्धृत परिणाम 1:20:82 की लागत अनुपात का संकेत देते हैं। यही है, डिजाइन या कोड निरीक्षण में पाया गया एक दोष 1. का लागत-में-परिवर्तन है। यदि एक ही दोष परीक्षण में बच जाता है, तो यह 20 गुना अधिक खर्च होगा। यदि यह उपयोगकर्ता के लिए सभी तरह से बच जाता है, तो यह 82 तक की लागत-से-सही कई हो जाएगा। कन, आईबीएम के रोचेस्टर, मिनियासोटा सुविधा के नमूना डेटा का उपयोग करते हुए, एएस / 400 परियोजना के लिए दोष हटाने की लागत समान होने का पता चला 1:13:92 पर। हालांकि, वह बताते हैं कि लागत में वृद्धि दोष खोजने के लिए बढ़ी हुई कठिनाई के कारण हो सकती है।
गिल्ब के 1993 ( "सॉफ्टवेयर निरीक्षण" ) और 1999 ("सॉफ्टवेयर इंजीनियरिंग विनिर्देश और गुणवत्ता नियंत्रण प्रक्रियाओं का अनुकूलन") सॉफ्टवेयर निरीक्षण पर प्रकाशन अन्य अध्ययनों को पुष्टि करने के लिए उल्लेखित हैं।
कांस्ट्रेक्स के पृष्ठ पर दोषपूर्ण लागत वृद्धि पर अतिरिक्त जानकारी मिल सकती है , जो दोष-मरम्मत लागत में वृद्धि पर कई संदर्भ प्रदान करती है। यह ध्यान दिया जाना चाहिए कि स्टीव मैककोनेल, कोड कम्प्लीट के लेखक, कॉन्स्ट्रेक्स के लिए स्थापित और काम करते हैं।
मैं हाल ही में की बात सुनी एक टॉक रियल सॉफ्टवेयर इंजीनियरिंग , द्वारा दिए गए ग्लेन Vanderburg 2010 वह मैदान पर एक ही बात को देखते हुए में लोन स्टार रूबी सम्मेलन में स्कॉटिश रूबी सम्मेलन और Erubycon 2011 में, 2012 में QCon सैन फ्रांसिस्को , और ओ रेली सॉफ्टवेयर वास्तुकला सम्मेलन 2015 में । मैंने केवल लोन स्टार रूबी सम्मेलन की बात सुनी है, लेकिन समय के साथ बात विकसित हुई है क्योंकि उनके विचारों को परिष्कृत किया गया था।
वेंडरबर्ग का सुझाव है कि इस ऐतिहासिक डेटा के सभी वास्तव में समय की प्रगति के रूप में दोषों को ठीक करने की लागत दिखा रहे हैं, जरूरी नहीं कि एक परियोजना चरणों के माध्यम से आगे बढ़े। पहले वर्णित कागजात और पुस्तकों में जांच की गई कई परियोजनाएं क्रमिक "झरना" परियोजनाएं थीं, जहां चरण और समय एक साथ चले गए। हालांकि, पुनरावृत्ति और वृद्धिशील परियोजनाओं में एक समान पैटर्न उभरेगा - यदि एक दोष को एक पुनरावृत्ति में इंजेक्ट किया गया था, तो उस पुनरावृत्ति को ठीक करना अपेक्षाकृत सस्ता होगा। हालांकि, जैसे-जैसे पुनरावृत्तियों में प्रगति होती है, बहुत सारी चीजें होती हैं - सॉफ्टवेयर अधिक जटिल हो जाता है, लोग विशेष मॉड्यूल या कोड के कुछ हिस्सों में काम करने के बारे में कुछ मामूली विवरण भूल जाते हैं, आवश्यकताएं बदल जाती हैं। ये सभी दोष को ठीक करने की लागत में वृद्धि करेंगे।
मुझे लगता है कि यह शायद वास्तविकता के करीब है। एक झरने की परियोजना में, लागत बढ़ जाती है क्योंकि कलाकृतियों की मात्रा जो एक अपस्ट्रीम समस्या के कारण सही होने की आवश्यकता होती है। सॉफ्टवेयर में जटिलता की वृद्धि के कारण, पुनरावृत्ति और वृद्धिशील परियोजनाओं में लागत बढ़ जाती है।