शिथिल युग्मित डिज़ाइन बनाने में मुझे कितना प्रयास करना चाहिए?

Question

मैं वर्तमान में डिजाइन पैटर्न के बारे में सीख रहा हूं।

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

इसे ध्यान में रखते:

मैं जो किताब पढ़ रहा हूं (हेड फर्स्ट डिजाइन पैटर्न) अक्सर ढीली कपलिंग के महत्व पर जोर देता है । इस ढीले युग्मन को such प्रोग्राम टू ए इंटरफ़ेस, नॉट इम्प्लीमेंटेशन ’और ulate इनकैप्सुलेट वाइज क्या होता है’ जैसे सिद्धांतों का पालन करके प्राप्त किया जाता है।

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

मैं ढीले युग्मन के महत्व और लाभों को समझता हूं।

लेकिन मेरा सवाल यह है कि वास्तव में शिथिल युग्मित, लचीले डिज़ाइन बनाने में कितना प्रयास करना चाहिए?

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

जो मैं जानना चाहता हूं, वह यह है कि मुझे वास्तव में अमूर्तता और डिजाइन के अतिरिक्त स्तर बनाने में कितना प्रयास करना चाहिए, केवल अपने आवेदन को OO सिद्धांतों का पालन करने की अनुमति देने के लिए जैसे ढीली युग्मन, एक इंटरफ़ेस के लिए प्रोग्राम करना, आदि क्या यह वास्तव में लायक है। यह? इसमें मुझे कितना प्रयास करना चाहिए?

Comments

कुछ लोगों ने इसके लिए पूरी जिंदगी लगा दी, उदाहरण के लिए केंट बेक, इसकी सराहना करने वाले लोग आपके प्रयास को देखेंगे।

— निंग

Answer 1

मोटा जवाब: जितना अधिक आप इसे करते हैं, उतना कम प्रयास।

असल में, शिथिल युग्मित कोड का निर्माण वास्तव में बहुत कठिन नहीं है। दूसरी ओर, ढीले युग्मन के संदर्भ में सोचने के लिए अपने दिमाग को प्रशिक्षित करना, है। और, ठीक है, मेरा मानना ​​है कि यह पूरी तरह से इसके लायक है।

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

ऐसा होता है। बहुत। यह या तो परियोजनाओं को देर से चलाता है, या यह हर किसी को ऐसा करने से डरता है जो बाद के पुनरावृत्तियों में किया जाना चाहिए। सबसे अच्छी स्थिति में, आपको मिट्टी की एक बड़ी गेंद मिलती है। ढीली युग्मन और एकल जिम्मेदारी सिद्धांत जैसी चीजें इन समस्याओं को बड़े पैमाने पर कम करती हैं। यही कारण है कि SOLID सिद्धांतों को टाल दिया जाता है - वे वास्तव में मदद करते हैं।

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

Answer 2

आवश्यक प्रयास की मात्रा हमेशा आपको पर्याप्त बताने वाली नहीं है; मुझे लगता है कि एक बेहतर उपाय भुगतान अनुपात का प्रयास होगा। लेकिन यह पता लगाना कि भुगतान क्या हो सकता है हमेशा सीधा और त्रुटि मुक्त नहीं होता है।

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

एक चीज है जो आपको हमेशा (या जितनी करीब हो सके उतनी ही करनी चाहिए): अपने सॉफ़्टवेयर के व्यक्तिगत घटकों (OOP के लिए ऑब्जेक्ट्स, कार्यात्मक या प्रक्रियात्मक प्रोग्रामिंग के लिए कार्य) को ब्लैक बॉक्स में बनाना। एक ब्लैक बॉक्स एक ऐसी चीज है जिसके इंसिडेंस (कार्यान्वयन) के बारे में हम नहीं जानते या परवाह नहीं करते हैं।

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

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

प्रतिमानों को डिजाइन करने में एक आपत्ति यह है कि वे 'स्पष्ट' हैं या 'मैं उनके बारे में सुनने से पहले उनका उपयोग कर रहा था, केवल इस नाम से नहीं'। लोग उन आपत्तियों का कारण बन सकते हैं, या डिजाइन पैटर्न के प्रवर्तक उनके साथ पहली जगह पर आ सकते हैं, यह है कि वे उनके पीछे के सिद्धांतों को समझते थे।

ब्लैक बॉक्स का उपयोग करने से आपके कोड को एक समझदार तरीके से व्यवस्थित किया जाता है और वे आम तौर पर बहुत अधिक (यदि कुछ भी) खर्च नहीं करते हैं; हर जगह उनका उपयोग करें। एक डिज़ाइन पैटर्न या कुछ अन्य तकनीक का उपयोग करना जो अमूर्तता की एक परत को जोड़ता है या चीजों को जटिल करता है; कभी भी उनका उपयोग न करें क्योंकि वे सुंदर या साफ या चालाक हैं; जब वे समस्या को फिट करते हैं तो उनका उपयोग करें और लागत लाभ प्राप्त करने के लिए भुगतान करने के लायक है।

Answer 3

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

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

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

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

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

Answer 4

पैटर्न का उपयोग केवल वहीं किया जाना चाहिए जहां वे सबसे अच्छा समाधान हो सकते हैं या एक अच्छे समाधान के निर्माण में मदद कर सकते हैं (क्या आप सहमत हैं?)।

मैं कार्यान्वयन विवरण के रूप में डिज़ाइन पैटर्न को सख्ती से देखता हूं। यदि आप अपने सार्वजनिक एपीआई और उस दस्तावेज को प्रोग्राम करते हैं, तो सामान्य तौर पर यह आपके लिए कोई मायने नहीं रखता (या आपको बहुत प्रभावित करता है) जहां आपके पास डिजाइन पैटर्न हैं। यही है, आप "मैं यहाँ एक पुल पैटर्न नहीं है, और मैं इसे ऊपर एक आगंतुक लागू करेंगे" मत जाओ। इसके बजाय, यह "इस वर्ग के विभिन्न ऑपरेटिंग सिस्टम पर अलग-अलग कार्यान्वयन होंगे इसलिए इसे एक पुल पैटर्न का उपयोग करके लागू किया जाएगा"। फिर, जब आप इसका उपयोग करते हैं, तो आप इसे एक पुल के रूप में लागू किए जाने के प्रति उदासीन होते हैं - क्योंकि आप सार्वजनिक एपीआई को देखते हैं, पुल के पैटर्न को नहीं।

शिथिल कपल्स, लचीले डिज़ाइन बनाने में वास्तव में कितना प्रयास करना चाहिए?

नियमों के एक सरल सेट का पालन करके ढीली युग्मन प्राप्त किया जा सकता है। यदि आप इनका सम्मान करते हैं, तो आपका कोड (अधिक) शिथिल युग्मित होगा, जैसा कि आप इसे लिखते हैं (यानी कोई भी प्रयास पहले से ही विकास प्रक्रिया का हिस्सा है)।

नियमों के बीच (एक विस्तृत सूची नहीं):

• ग्राहक कोड (कैसे वर्ग का उपयोग किया जाएगा) सोच (या लेखन) द्वारा अपने इंटरफेस को परिभाषित करें, न कि कक्षा क्या करेगी (यानी इंटरफ़ेस के लिए इच्छुक, कार्यान्वयन नहीं)
• "बताओ, मत पूछो"
• पहले से निर्मित भागों से वस्तुओं का निर्माण
• कंस्ट्रक्टर में पास करें जो वास्तविक वस्तुओं का आप उपयोग करेंगे (सदस्यों के लिए कारखानों नहीं, मापदंडों के कारखानों के लिए पैरामीटर, या ऐसा कुछ भी)।
• DRY (यदि आपके पास दो लाइनें हैं जो एक ही क्रम में दो स्थानों पर दिखाई देती हैं, तो उन्हें एक अलग फ़ंक्शन और इसी तरह निकालें)।
• यदि किसी ऑब्जेक्ट का निर्माण एक अधिक जटिल ऑपरेशन है, तो कारखाने के तरीके / वर्ग (यानी निर्माणकर्ता निकाय में नहीं) के रूप में मध्यस्थ भागों के निर्माण को लागू करें।
• YAGNI (पहले जैसी चीजें बनाएं, उनकी जरूरत है)।

इन नियमों का अलग-अलग तरीके से पालन किया जाता है, भाषा के आधार पर, आपकी टीम (जैसे TDD), समय बजट की कमी आदि के बाद विकास पद्धति।

उदाहरण के लिए, जावा में, अपने इंटरफ़ेस को एक के रूप में परिभाषित करने interfaceऔर उस पर क्लाइंट कोड लिखने के लिए अच्छा अभ्यास है (फिर, एक कार्यान्वयन वर्ग के साथ इंटरफ़ेस को त्वरित करें)।

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

जो लोग डिजाइन पैटर्न का विरोध करते हैं, वे कहते हैं कि इन पैटर्नों का उपयोग करने की लागत अक्सर लाभ से आगे निकल जाती है।

मुझे लगता है कि वे गलत कर रहे हैं। यदि आप शिथिल युग्मित (और DRY) कोड लिखते हैं, तो इसमें डिज़ाइन पैटर्न को एकीकृत करना न्यूनतम अतिरिक्त प्रयास के साथ आता है। अन्यथा, आपको एक डिज़ाइन पैटर्न लागू करने के लिए अपने कोड को अनुकूलित करना होगा।

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

जो मैं जानना चाहता हूं, वह यह है कि मुझे वास्तव में अमूर्तता और डिजाइन के अतिरिक्त स्तर बनाने में कितना प्रयास करना चाहिए, केवल अपने आवेदन को OO सिद्धांतों का पालन करने की अनुमति देने के लिए जैसे ढीली युग्मन, एक इंटरफ़ेस के लिए प्रोग्राम करना, आदि क्या यह वास्तव में लायक है। यह? इसमें मुझे कितना प्रयास करना चाहिए?

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

ढीले युग्मन के लाभों में से हैं:

• रिफैक्टरिंग और रिडिजाइन लचीलेपन
• कम बर्बाद किया गया प्रयास
• testability
• कोड का पुन: उपयोग करने की संभावना बढ़ गई
• डिजाइन सादगी
• डिबगर में कम समय बिताया

... और कुछ अन्य जो अभी मेरे दिमाग में नहीं आते हैं।