पहले से लिखे गए कोड का समर्थन करने के लिए आपको कितने प्रोग्रामर चाहिए?

कुछ समय पहले, मेरे और मेरे अच्छे दोस्त के बीच एक बातचीत हुई, जिसमें निम्नलिखित वाक्यांशों की आवाज़ आई:

- प्रोग्रामर की संख्या लगातार बढ़ेगी - क्योंकि कोड की मात्रा बढ़ रही है, और अधिक से अधिक डेवलपर्स को लगातार इसका समर्थन करने की आवश्यकता है।
- लेकिन कोड उम्र बढ़ने वाला है, इसका एक हिस्सा समर्थन छोड़ रहा है। किसी प्रकार के संतुलन की उपस्थिति से इंकार नहीं किया जाता है।

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

पहला सवाल। सभी विकास संसाधनों को "खाने" का समर्थन कर सकते हैं?

प्रोग्रामर की एक टीम पर विचार करें जिसमें प्रतिभागियों की संख्या स्थिर है। उनके काम करने के समय का हिस्सा $$$\ mu (t)$ ( $$$0 <\ _ म्यू (टी) <1$ ) नए कोड और समय के शेष अंश के विकास पर पड़ता है $$$1- \ _मु (t)$ समर्थन करने जाता है। मॉडल की मान्यताओं के तहत, मान लीजिए कि पहली प्रकार की गतिविधि का उद्देश्य कोड की मात्रा में वृद्धि करना है, और दूसरा - इसे बदलने में (त्रुटियों को सही करना) और कोड की मात्रा को महत्वपूर्ण रूप से प्रभावित नहीं करता है।

हम निरूपित करते हैं $$$y (t)$ समय के अनुसार सभी कोड $$$टी$ । कोड लिखने की गति को ध्यान में रखते हुए आनुपातिक है $$$\ mu (t)$ हमें मिलता है:

$$

$$\ frac {डाई (t)} {dt} = a_0 \ mu (t); a_0 \ in \ mathbb {R}, a_0> 0.$$

यह मानना ​​स्वाभाविक है कि कोड को बनाए रखने में शामिल श्रम इसकी मात्रा के लिए आनुपातिक है:

$$

$$1- \ _मु (t) = a_1 y (t); a_1 \ in \ mathbb {R}, a_1> 0$$

या

$$

$$\ mu (t) = 1-a_1y (t)$$

कहाँ से?

$$

$$\ frac {डाई (t)} {dt} = a_0 (1-a_1y (t)) $$$

हमें एक अंतर समीकरण मिलता है जो आसानी से एकीकृत होता है। यदि समय के प्रारंभिक क्षण में कोड की मात्रा शून्य है, तो

$$

$$y (t) = \ frac {1} {a_1} (1-e ^ {- a_0a_1t) $$$

पर $$$t \ से + \ infty$ समारोह $$$y (t) \ _1 / a =$ , और $$$\ _मु (t) \ _ से ०$ । और इसका अर्थ है नई कार्यक्षमता के विकास के समय में धीरे-धीरे कमी और समर्थन के लिए सभी संसाधनों का संक्रमण।

हालांकि, अगर समय में $$$h> 0$ चूंकि कोड अप्रचलित हो जाता है और समर्थित होना बंद हो जाता है, कोड की मात्रा को एक समय में समर्थन की आवश्यकता होती है $$$टी$ के बराबर है $$$y (t) - y (t-h)$ तो

$$

$$1- \ _ mu (t) = a_1 (y (t) - y (t-h)),$$

$$

$$\ mu (t) = 1-a_1 (y (t) - y (t-h)),$$

और $$$y (t)$ विलंबित तर्क के साथ एक विभेदक समीकरण का हल है [1]:

$$

$$\ frac {डाई (t)} {dt} = a_0 (1-a_1 (y (t) - y (t-h)) $$$

मूल्यों को सेट करके इस समीकरण का समाधान विशिष्ट रूप से निर्धारित किया जाता है $$$y (t)$ "समय की शुरुआत से पहले", के साथ $$$t \ में [-h, 0]$ । चूंकि हमारे समय में, शुरुआती समय से पहले कोई कोड नहीं लिखा गया था $$$y (t) = 0$ पर $$$t \ में [-h, 0]$ ।

आइए कुछ उदाहरण देखें। हम वर्षों में समय, और हजारों लाइनों में कोड की मात्रा को मापेंगे। फिर के लिए $$$a_0$ दसियों के क्रम के मूल्य स्वीकार्य हैं, हम 50 और 100 लेते हैं। अर्थात्, एक वर्ष में विकास टीम क्रमशः कोड की पचास और एक सौ हजार पंक्तियां लिखेगी। के लिए $$$a_1$ स्वीकार्य मूल्य हो सकते हैं: $$$0.25 / a_0$ । $$$0.5 / a_0$ । $$$1 / a_0$ । इसका मतलब यह है कि विकास टीम एक चौथाई, आधा या पूर्ण कार्यभार के साथ वर्ष के लिए लिखे गए कोड की मात्रा को बनाए रखने में सक्षम है। कोड के औसत जीवन काल के रूप में, आइए मानों को निर्धारित करें: 1, 2 और 4 साल। समीकरण को संख्यात्मक रूप से हल करते हुए, हम फ़ंक्शन के व्यवहार के उदाहरण प्राप्त करते हैं $$$\ mu (t)$ मापदंडों के कुछ संयोजनों के लिए $$$h, a_0, a_1$ ।

समारोह व्यवहार $$$\ mu (t)$ उम्र बढ़ने के चेहरे में कोड बदल गया है। समारोह नीरस होना बंद हो गया है, लेकिन समय के साथ उतार-चढ़ाव "शांत" होते हैं, इसके प्रति झुकाव होता है $$$\ mu (t)$ कुछ निरंतर मूल्य के लिए। चार्ट दिखाते हैं: अधिक $$$ज$ । $$$a_0$ और $$$a_1$ , अर्थात्, कोड धीमा हो जाता है, तेजी से नए कोड का विकास होता है और कोड की गुणवत्ता कम होती है, नई कार्यक्षमता के विकास के लिए कम संसाधन रहेंगे। जिसमें कम से कम एक उदाहरण देने की इच्छा थी $$$\ mu (t)$ "स्नगल्ड" शून्य के करीब। लेकिन इसके लिए बहुत खराब विकास गुणवत्ता संकेतकों और लंबे समय से उम्र बढ़ने वाले कोड के चयन की आवश्यकता थी। निचले बाएँ ग्राफ़ में भी, नई कार्यक्षमता के लिए संसाधनों की एक महत्वपूर्ण राशि बनी हुई है। इसलिए, पहले प्रश्न का सही उत्तर इस बात की अधिक संभावना है: सैद्धांतिक रूप से - हां, यह संभव है; व्यावहारिक रूप से - शायद ही।

जिन सवालों का जवाब नहीं दिया जा सका है:

1. क्या यह सच है $$$\ mu (t)$ के लिए एक निश्चित सीमा तक जाता है $$$t \ से + \ infty$ सभी के लिए $$$a_0, a_1> 0$ ? यदि सभी के लिए नहीं है, तो किसके लिए?
2. यदि सीमा मौजूद है, तो इसका मूल्य कैसे निर्भर करता है $$$a_0, a_1$ ?

दूसरा सवाल। क्या कोड समर्थन प्रोग्रामर की संख्या में असीमित वृद्धि का कारण बन सकता है?

हम निरूपित करते हैं $$$q (t)$ नए कोड के विकास में शामिल प्रोग्रामर की संख्या। ऊपर के रूप में $$$y (t)$ - समय के अनुसार कोड की मात्रा $$$टी$ । तो

$$

$$\ frac {डाई (t)} {dt} = a_2 q (t); a_2 \ in \ mathbb {R}, a_2> 0.$$

कोड को व्यस्त होने दें $$$p (t)$ प्रोग्रामर। सी कोड उम्र बढ़ने

$$

$$p (t) = a_3 (y (t) -y (t-h)); a_3 \ in \ mathbb {R}, a_3> 0.$$

कहाँ से?

$$

$$p (t) = a_3 \ int_ {t-h} ^ {t} \ frac {dy (s)} {ds = ds = a_2a_3 \ int_ {t-h} ^ tq (s) $ s$$

अगर $$$q (t) \ leq C_1$ तो

$$

$$p (t) \ leq a_1a_2C_1h।$$

इस प्रकार, दूसरे प्रश्न का उत्तर नकारात्मक है: यदि नए कोड के डेवलपर्स की संख्या सीमित है, तो उम्र बढ़ने के कोड के संदर्भ में, समर्थन प्रोग्रामर की संख्या में असीमित वृद्धि का कारण नहीं बन सकता है।

निष्कर्ष

माना जाता है कि मॉडल "नरम" गणितीय मॉडल हैं [2]। वे बहुत सरल हैं। फिर भी, पैरामीटर मूल्यों पर सिमुलेशन परिणामों की निर्भरता वास्तविक प्रणालियों के लिए अपेक्षित है, यह मॉडल की पर्याप्तता और गुणात्मक अनुमान प्राप्त करने के लिए पर्याप्त सटीकता के पक्ष में बोलती है।

संदर्भ

1. एल्सगोल्ट्स एल.ई., नोरकिन एस.बी. विचलित तर्क के साथ अंतर समीकरणों के सिद्धांत का परिचय। मास्को। पब्लिशिंग हाउस "साइंस"। 1971।
2. अर्नोल्ड वी.आई. "हार्ड" और "सॉफ्ट" गणितीय मॉडल। मास्को। केंद्र का प्रकाशन गृह। 2004।