रिफैक्टरिंग कैसे कोड को सरल बनाती है: विचारशील अमूर्तता की शक्ति

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

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

सॉफ्टवेयर विकास में सबसे कठिन समस्या क्या है?

"कंप्यूटर साइंस में केवल दो कठिन समस्याएं हैं: कैश इनवैलिडेशन और चीजों का नामकरण।"

– फिल कार्लटन

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

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

मान्यताओं के माध्यम से सरलीकरण

अगर आपके पास फोटोग्राफिक मेमोरी होती, और आप याद रख सकते कि आपके प्रोग्राम के सभी अलग-अलग हिस्से कैसे एक साथ फिट होते हैं, तो आपके पास बहुत कम बग होते, है ना? मेमोरी बनाना कठिन हो सकता है। लेकिन आप एक समय में एक चीज पर ध्यान केंद्रित करने में सक्षम होने से बहुत सारे समान लाभ प्राप्त कर सकते हैं।

सॉफ्टवेयर विकास में कई सर्वोत्तम प्रथाएं एक बार में आपके दिमाग में रखने वाली चीजों की संख्या को कम करने के बारे में हैं। कुछ उदाहरण:

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

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

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

यही कारण है कि बुरे अमूर्तता बिना किसी अमूर्तता के से भी बदतर हैं, और आप कोड पर तब तक "एक्सट्रैक्ट मेथड" नहीं फेंक सकते जब तक कि यह जादुई रूप से अच्छा न हो जाए।

सही रिफैक्टरिंग, सही जगह

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