The Importance of Code Ownership. Well-owned code is well-maintained code | by Elye | Nov, 2022

सॉफ्टवेयर की दुनिया

अच्छी तरह से स्वामित्व वाला कोड अच्छी तरह से बनाए रखा कोड है

द्वारा तसवीर टिएरा मल्लोर्का पर unsplash

“तुम इसे लिखो; यह आपका है।” यह एक सॉफ्टवेयर इंजीनियरिंग विभाग का दर्शन है जिसमें मैंने एक बार काम किया था। किसी भी लिखित कोड के लिए जवाबदेही सुनिश्चित करना एक महान दर्शन है।

लेकिन यह करने से कहना आसान है।

कोड स्वामित्व, हालांकि यह सरल लगता है, यह भी एक है जिसे समय के साथ आसानी से छोड़ा जा सकता है। इसका परिणाम बहुत बड़ा है। कोड स्पेगेटी, अप्राप्य, और जल्द ही एक विरासत का टुकड़ा बन जाएगा $#!+ कि कोई यह पता नहीं लगा सकता कि यह कैसे काम करता है।

कोड का प्रत्येक टुकड़ा किसी के द्वारा लिखा गया है, इसलिए लेखक मालिक है, है ना?

यह बहुत ही सरल दृष्टिकोण है। यह केवल एक एकल परियोजना या एक छोटी परियोजना के लिए एक छोटी टीम पर लागू होता है।

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

यह कैसे होता है यह जानने के लिए, एक परियोजना के कोड विकास के सात चरण नीचे दिए गए हैं जो बदसूरत हो जाते हैं।

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

एक व्यक्ति अनिवार्य रूप से कोड का मालिक होता है।

कोड अच्छी तरह से समझे जाते हैं और मुख्य देव के स्वामित्व में होते हैं

हमारे पास अधिक डेवलपर कोड में योगदान देना शुरू करते हैं। शायद 3-5 डेवलपर्स की एक टीम। हमारे पास सहकर्मी कोड समीक्षाएं हैं। हमारे पास कोड पेयरिंग है। कोड के सभी भागों को हर कोई समझता है। हमारे पास एक मुख्य लीड डेवलपर है जो सम्मेलन का पालन करने का निर्णय लेता है। स्वच्छ और सुसंगत।

टीम अनिवार्य रूप से कोड का मालिक है।

कोड अच्छी तरह से समझे जाते हैं और टीम के स्वामित्व में होते हैं

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

प्रत्येक डेवलपर सुविधाओं के अपने हिस्से का स्वामी होता है, लेकिन सभी सामान्य परत के स्वामी होते हैं। हर कोई सामान्य परत का उपयोग करना पसंद करता है, लेकिन लोग इसे संशोधित करने से बचने का प्रयास करते हैं, क्योंकि इसमें अन्य सभी के कोड को भी बदलना शामिल हो सकता है।

कोई भी सामान्य कोड का मालिक नहीं है। समय के साथ, सामान्य कोड की समझ फीकी पड़ जाती है

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

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

फ़ेडरेटेड कोड हो गए हैं लेकिन स्वामित्व में नहीं हैं। हालाँकि, टीम को अंततः फ़ेडरेटेड कोड का स्वामी होना चाहिए, लेकिन इसे पूरी तरह से समझना नहीं चाहिए। ऐसा इसलिए है क्योंकि उनके पास अन्य विशेषताएं हैं जिन पर वे काम कर रहे हैं, इसलिए संघ कोड को आंशिक रूप से समझ रहे हैं।

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

किसी को भी जनरेट किए गए कोड का स्वामी होने की आवश्यकता नहीं है, क्योंकि यह “अच्छी तरह से उत्पन्न” है। समय के साथ, डेवलपर इसका उपयोग करता है, लेकिन यह नहीं जानता कि यह कैसे कार्य करता है क्योंकि इसकी “कोई आवश्यकता नहीं है”। स्मार्ट डेवलपर कोड जनरेटर का मालिक है … लेकिन लंबे समय तक नहीं … (नीचे चरण 6 देखें)

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

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

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

कोड को समझने के लिए पर्याप्त समय के साथ उचित पास-डाउन नहीं होने पर संक्रमण का कोड पर सबसे खराब प्रभाव पड़ता है। नए डेवलपर्स जो मूल कोड नहीं लिखते हैं वे कोड से दूर महसूस करते हैं। सबसे खराब बात यह है कि जटिल कोड जनरेटर को कोई भी आसानी से समझ नहीं सकता है।

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

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

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

हर कोई जहाज से कूदना और नए कोडबेस पर काम करना पसंद करता है। पुराना कोड अब एक प्रेतवाधित घर है जिससे हर कोई बचने की कोशिश करता है

जैसा कि आप अंत में देख सकते हैं, डेवलपर्स अब मूल कोड पर काम करना पसंद नहीं करते हैं जो कि बढ़ने और स्केल करने के लिए अच्छी तरह से इरादा था।

ऊपर से, ऐसा लग सकता है कि समस्या “पुन: प्रयोज्य,” “संघ,” “स्वचालन,” और “संक्रमण” के कारण हुई, लेकिन वे इस मुद्दे का मूल कारण नहीं हैं।

मूलभूत मुद्दे सभी एक सामान्य मुद्दे पर उबालते हैं, “समय के साथ कोड स्वामित्व की फीका भावना।”

जैसा कि हम देखते हैं, यह सब अच्छी तरह से शुरू हुआ। लेकिन जैसे-जैसे समय बीतता है, चीजें बद से बदतर होती जाती हैं और नीचे की ओर बढ़ती जाती हैं। नीचे कुछ कारण दिए गए हैं:

1. लगातार बढ़ती सुविधाएँ

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

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

2. हर कोई इसका मालिक है = कोई भी इसका मालिक नहीं है

यह सामान्य कोड के साथ होता है। यदि कॉमन कोड की देखरेख करने वाला कोई एक व्यक्ति या टीम नहीं है, तो बहुत जल्द, यह या तो बन जाएगा:

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

3. इसे कोड करें लेकिन इसका स्वामी नहीं है

कुछ संगठन डेवलपर्स के एक समूह को पसंद करते हैं जो प्रत्येक प्रोजेक्ट को अस्थायी रूप से समर्थन देने के लिए प्रोजेक्ट से प्रोजेक्ट पर जाते हैं और दूसरे पर जाते हैं। विचार कई परियोजनाओं में संसाधनों को साझा करना है।

जबकि यह संगठन के लिए “व्यवसाय के अनुकूल” लगता है क्योंकि संसाधनों को साझा किया जाता है, चुनौती यह है कि आखिरकार उनके द्वारा लिखे गए कोड का मालिक कौन होगा?

एक हार्डवेयर उत्पाद के विपरीत, एक सॉफ्टवेयर उत्पाद हमेशा जीवित रहता है और इसे अच्छी तरह से समझने और बनाए रखने के लिए समय-समय पर बदलने की आवश्यकता होती है। लेकिन इस तरह के कोड के सिर्फ “अस्थायी” स्वामित्व के साथ, यह जल्द ही बासी हो जाएगा।

4. जटिलता के साथ सरलीकरण

कोडिंग में तेजी लाने में मदद करने के लिए, कभी-कभी डेवलपर्स कॉम्प्लेक्स का निर्माण करते हैं

  • कोड जनरेटर बॉयलरप्लेट से बचने के लिए
  • आधार वर्ग या कार्य जो इसके उपयोग को सरल बनाने के लिए मानते हैं

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

बहुत जल्द, कोई भी यह नहीं समझ पाएगा कि यह कैसे काम करता है, और कोई भी इसे छूना नहीं चाहेगा।

5. हम हमेशा नहीं रहेंगे

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

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

  • कोड भी नहीं समझते
  • कोड से कोई लगाव महसूस नहीं हो रहा है
  • कोड कैसे किया जाना चाहिए, इसके बारे में अलग-अलग प्राथमिकताएँ हैं

उपरोक्त सभी कारणों से, वर्तमान कोड आधार के स्वामित्व की भावना बिगड़ने की संभावना है

उचित स्वामित्व प्रबंधन सुनिश्चित करने के लिए, या तो एक व्यक्ति या एक टीम द्वारा, नीचे कुछ अनुशंसित विचार दिए गए हैं:

1. साझा-स्वामित्व को ना कहें

“साझा स्वामित्व” के रूप में कोई कोड नहीं छोड़ा जाना चाहिए। यदि हम आम तौर पर कुछ सामान्य कोड साझा करना चाहते हैं, तो इसमें एक डेवलपर या एक टीम भी होनी चाहिए जो पूरी तरह से इसका मालिक हो।

मालिक को कोड वेलनेस बनाए रखना चाहिए, कोड में योगदान करने का मार्गदर्शक सिद्धांत (स्वामित्व वाला कोड अभी भी दूसरों को योगदान करने की अनुमति देता है, किसी भी खुले स्रोत की तरह)।

2. स्पष्ट सीमा और स्वायत्तता

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

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

3. कोड, एक बार भेज दिए जाने के बाद, नहीं किया जाता है

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

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

4. कोड विलोपन स्वस्थ है

यह देखते हुए कि प्रत्येक कोड का स्वामित्व है और समय-समय पर इसके ओवरहाल के लिए समय आवंटित करने की आवश्यकता है, प्रत्येक डेवलपर केवल कोड के एक निश्चित आकार का स्वामी हो सकता है।

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

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

5. स्वचालन मुक्त नहीं है

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

वास्तविक भारी लागत बाद में आती है – इसका रखरखाव। हमें यह सुनिश्चित करने की आवश्यकता है कि कोई न केवल इसका स्वामी है बल्कि इसे पूरी तरह से समझता है। यह सुनिश्चित करने के लिए है कि भविष्य में आवश्यक किसी भी मुद्दे या संवर्द्धन से निपटा जा सके। ऐसा काम आमतौर पर बाद के मालिक के लिए चुनौतीपूर्ण होता है जो ऑटोमेशन कोड के संदर्भ को नहीं जानता है।

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

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

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

ज्यादातर मामलों में, समस्या यह है कि यह कोड अब अच्छी तरह से स्वामित्व में नहीं है। एक बार ऐसा होने के बाद, कोड की गुणवत्ता कम हो जाएगी, अंततः अप्रबंधनीय हो जाएगी।

किसी भी रिश्ते की तरह, कोड को निरंतर “प्रेम” की आवश्यकता होती है। अगर हम लगातार इसका “पोषण” करते हैं, तो यह फलता-फूलता रहेगा। यदि नहीं, तो यह तेजी से बूढ़ा हो जाएगा और जल्द ही वापस आकर हमें परेशान करेगा।

Leave a Reply