अगले डेवलपर के लिए कोडिंग के 5 चरण

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

केंट बेक अच्छे प्रोग्रामर के बारे में:

कोई भी मूर्ख ऐसा कोड लिख सकता है जिसे कंप्यूटर समझ सके। अच्छे प्रोग्रामर ऐसा कोड लिखते हैं जिसे मनुष्य समझ सके।

डगलस क्रॉकफोर्ड अच्छे कंप्यूटर प्रोग्राम के बारे में:

यह सब संचार और उन संरचनाओं तक आता है जिनका उपयोग आप उस संचार को सुविधाजनक बनाने के लिए करते हैं। मानव भाषा और कंप्यूटर भाषाएं कई तरीकों से बहुत अलग तरीके से काम करती हैं, लेकिन अंततः मैं एक अच्छे कंप्यूटर प्रोग्राम का मूल्यांकन इसकी क्षमता से करता हूं कि वह एक मनुष्य के साथ संचार कर सके जो उस प्रोग्राम को पढ़ता है। तो उस स्तर पर, वे इतने अलग नहीं हैं।

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

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

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

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

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

कुछ कोड बस परेशान करने वाला है, एक साथी तक पहुंचें — आंखों का एक दूसरा सेट हमेशा मदद करता है। कोड को एक साथ चलाएं। आप आश्चर्यचकित होंगे कि आप दोनों क्या पाएंगे।

अगले डेवलपर्स के लिए रोटी के टुकड़े छोड़ने के 5 सुझाव यहां दिए गए हैं

1. पैटर्न
ज्ञात पैटर्न का उपयोग करें, अपने स्वयं के पैटर्न बनाएं। पूरे कोड में एक सुसंगत प्रतिमान के साथ रहें। उदाहरण के लिए, डेटा एक्सेस के लिए 3 दृष्टिकोण न रखें।

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

असंगत कोड एक दुःस्वप्न है, कल्पना करें कि एक किताब पढ़ रहे हैं जहां हर शब्द का अर्थ कुछ अलग है, विभिन्न स्थानों पर एक ही शब्द सहित। आपको हर शब्द को देखना होगा और इरादे की खोज में बड़ी मानसिक ऊर्जा खर्च करनी होगी। यह निराशाजनक, थकाऊ और दर्दनाक है। आप पागल हो जाएंगे! अगले डेवलपर के साथ ऐसा न करें।

3. विस्तृत नामकरण
यह आपकी भाषा है। ये आपकी कहानी के शब्द हैं। उन्हें अच्छी तरह से बुनें।

इसमें क्लास के नाम, विधि के नाम, चर के नाम, प्रोजेक्ट के नाम और संपत्ति के नाम शामिल हैं।

न करें:

if(monkey.HoursSinceLastMeal > 3)
{
    FeedMonkey();
}

करें:

int feedInterval = 3;

if(monkey.HoursSinceLastMeal > feedInterval)
{
    FeedMonkey();
}

पहले उदाहरण में if स्टेटमेंट में 3 हार्डकोड है। यह कोड वाक्यविन्यास की दृष्टि से सही है, लेकिन संख्या 3 का इरादा आपको कुछ नहीं बताता। संपत्ति को देखते हुए जिसका मूल्यांकन किया जा रहा है, आप अनुमान लगा सकते हैं कि यह वास्तव में 3 घंटे है। वास्तव में हम नहीं जानते। हम एक धारणा बना रहे हैं।

दूसरे उदाहरण में, हम 3 को ‘feedInterval’ नामक एक चर में सेट करते हैं। इरादा चर के नाम में स्पष्ट रूप से बताया गया है। यदि पिछले भोजन के बाद से 3 घंटे हो गए हैं, तो बंदर को खिलाने का समय है। चर को सेट करने का एक दुष्प्रभाव यह है कि हम अब तर्क को बदले बिना फीड अंतराल को बदल सकते हैं।

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

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

5. सरल कोड लिखें
मेरी व्यावसायिक राय में जटिल कोड लिखना डेवलपर्स के बीच सबसे बड़ी मूर्खता है।

स्टीव जॉब्स सरलता पर:

सरल जटिल से कठिन हो सकता है: आपको अपनी सोच को साफ करने के लिए कड़ी मेहनत करनी होगी ताकि इसे सरल बनाया जा सके। लेकिन यह अंत में इसके लायक है क्योंकि एक बार जब आप वहां पहुंच जाते हैं, तो आप पहाड़ों को हिला सकते हैं।

जटिलता कई रूपों में आती है, जिनमें कुछ शामिल हैं: भविष्य की सुरक्षा, अत्यधिक जटिल कार्यान्वयन, बहुत अधिक अमूर्तता, बड़ी क्लासें और बड़ी विधियां।

स्वच्छ सरल कोड लिखने के बारे में अधिक जानकारी के लिए, अंकल बॉब की किताब क्लीन कोड और मैक्स कनात-अलेक्जेंडर की कोड सरलता देखें।

समापन

कोड पढ़ना कठिन है। कुछ सरल चरणों के साथ आप यह सुनिश्चित कर सकते हैं कि अगला डेवलपर आपके कोड को समझ जाएगा।