इससे कोई फर्क नहीं पड़ता कि किसी चीज़ को कितनी मजबूती से जोड़ा जाता है अगर वह दूसरी चीज़ कभी नहीं बदलती है। मैंने पाया है कि आम तौर पर चीजों को बदलने के लिए कम से कम कारणों पर ध्यान केंद्रित करना, स्थिरता की तलाश करना, उन्हें युग्मन के शिथिल रूप को प्राप्त करने के लिए प्रयास करके बदलना आसान होता है।
Decoupling मैंने उस बिंदु के लिए बहुत उपयोगी पाया है, जहां मैं कभी-कभी मामूली कोड दोहराव को पैकेजों के अनुकूल बनाता हूं। एक मूल उदाहरण के रूप में, मुझे एक छवि पुस्तकालय को लागू करने के लिए अपने गणित पुस्तकालय का उपयोग करने का एक विकल्प था। मैंने कुछ बुनियादी गणित कार्यों की नकल नहीं की, जो कॉपी करने के लिए तुच्छ थे।
अब मेरी छवि पुस्तकालय पूरी तरह से गणित पुस्तकालय से स्वतंत्र है, जहां कोई फर्क नहीं पड़ता कि मैं अपने गणित के लिए किस तरह के बदलाव करता हूं, यह छवि पुस्तकालय को प्रभावित नहीं करेगा। यह सबसे पहले और सबसे महत्वपूर्ण स्थिरता है। छवि पुस्तकालय अब और अधिक स्थिर है, क्योंकि इसमें बदलाव के बहुत कम कारण हैं, क्योंकि यह किसी अन्य पुस्तकालय से डिकॉउन्ड किया गया है जो बदल सकता है (सी मानक पुस्तकालय के अलावा जो उम्मीद नहीं करनी चाहिए कि कभी बदल जाए)। एक बोनस के रूप में यह तैनात करना आसान है जब यह सिर्फ एक स्टैंडअलोन लाइब्रेरी है जो इसे बनाने और इसका उपयोग करने के लिए अन्य परिवादों के एक समूह में खींचने की आवश्यकता नहीं है।
स्थिरता मेरे लिए बहुत मददगार है। मुझे अच्छी तरह से परीक्षण किए गए कोड का एक संग्रह बनाना पसंद है जिसके भविष्य में कभी भी बदलाव के कम और कम कारण हैं। यह एक पाइप सपना नहीं है; मेरे पास C कोड है जो मैं 80 के दशक के अंत से फिर से उपयोग और उपयोग कर रहा हूं जो तब से बिल्कुल भी नहीं बदला है। यह पिक्सेल-उन्मुख और ज्यामिति-संबंधित कोड की तरह कम स्तर का सामान है, जबकि मेरा उच्च-स्तरीय सामान अप्रचलित हो गया है, लेकिन यह एक ऐसी चीज है जो अभी भी आसपास रहने में बहुत मदद करती है। यह लगभग हमेशा एक पुस्तकालय का मतलब है जो कम और कम चीजों पर निर्भर करता है, अगर बाहरी कुछ भी नहीं। यदि आपका सॉफ़्टवेयर तेजी से नींव पर निर्भर करता है तो विश्वसनीयता बढ़ती है और कुछ कारणों से बदलती है। कम चलती भागों वास्तव में अच्छा है, भले ही अभ्यास में चलती भागों स्थिर भागों की तुलना में बहुत अधिक हो।
ढीली कपलिंग एक ही नस में है, लेकिन मुझे अक्सर लगता है कि ढीली कपलिंग बिना कपलिंग के बहुत कम स्थिर है। जब तक आप एक ऐसे टीम में काम कर रहे हैं, जहाँ तक बेहतर इंटरफ़ेस डिज़ाइनर और क्लाइंट्स हैं, जो अपना दिमाग नहीं बदलते हैं, जैसा कि मैंने कभी भी काम नहीं किया, यहाँ तक कि शुद्ध इंटरफेस अक्सर उन तरीकों को बदलने का कारण पाते हैं, जो अभी भी पूरे कोड में कैस्केडिंग ब्रेक का कारण बनते हैं। यह विचार कि कंक्रीट के बजाय अमूर्त के प्रति निर्भरता को निर्देशित करके स्थिरता प्राप्त की जा सकती है, यदि इंटरफ़ेस डिजाइन कार्यान्वयन के बजाय पहली बार सही होने के लिए आसान है। मुझे अक्सर लगता है कि यह उलट है, जहां एक डेवलपर ने बहुत अच्छा बनाया हो सकता है, अगर अद्भुत नहीं है, तो कार्यान्वयन को डिजाइन आवश्यकताओं को देखते हुए उन्होंने सोचा कि उन्हें पूरा करना चाहिए, केवल भविष्य में यह पता लगाने के लिए कि डिजाइन की आवश्यकताएं पूरी तरह से बदल जाती हैं।
इसलिए मैं स्थिरता और पूर्ण डिकूपिंग को पसंद करता हूं ताकि मैं कम से कम आत्मविश्वास से कह सकूं, "इस छोटे से पृथक पुस्तकालय का उपयोग जो वर्षों से किया जा रहा है और पूरी तरह से परीक्षण करके सुरक्षित किया गया है, इसमें परिवर्तन की आवश्यकता के लगभग कोई संभावना नहीं है, जो दुनिया भर में अराजक हो जाता है। । " यह मुझे कुछ हद तक पवित्रता का टुकड़ा देता है, चाहे किसी भी प्रकार के डिजाइन परिवर्तन को बाहर के लिए कहा जाए।
युग्मन और स्थिरता, ईसीएस उदाहरण
मुझे एंटिटी-कंपोनेंट सिस्टम से भी प्यार है और वे बहुत तंग युग्मन का परिचय देते हैं क्योंकि सिस्टम निर्भरता को सभी एक्सेस करने और कच्चे डेटा को सीधे हेरफेर करने की कोशिश करता है, जैसे:
यहां सभी निर्भरताएं बहुत तंग हैं क्योंकि घटक कच्चे डेटा को उजागर करते हैं। निर्भरताएं अमूर्तता की ओर नहीं बढ़ रही हैं, वे कच्चे डेटा की ओर बह रही हैं, जिसका अर्थ है कि प्रत्येक सिस्टम में प्रत्येक प्रकार के घटक के बारे में अधिकतम ज्ञान संभव है, जिसे वे एक्सेस करने का अनुरोध करते हैं। कच्चे डेटा के साथ सभी प्रणालियों तक पहुँचने और छेड़छाड़ करने के लिए घटकों की कोई कार्यक्षमता नहीं है। हालाँकि, इस तरह के सिस्टम के बारे में तर्क करना बहुत आसान है क्योंकि यह बहुत सपाट है। यदि कोई बनावट खराब हो जाती है, तो आप तुरंत इस सिस्टम से जानते हैं कि केवल रेंडरिंग और पेंटिंग सिस्टम एक्सेस टेक्सचर कंपोनेंट्स का उपयोग करते हैं, और आप संभवतः रेंडरिंग सिस्टम को नियमबद्ध कर सकते हैं क्योंकि यह केवल टैक्स्चर से पढ़ता है।
इस बीच एक ढीला युग्मित विकल्प यह हो सकता है:
... अमूर्त कार्यों की ओर बहने वाली सभी निर्भरताओं के साथ, डेटा नहीं, और उस आरेख में हर एक चीज एक सार्वजनिक इंटरफ़ेस और स्वयं की कार्यक्षमता को उजागर करती है। यहाँ सभी निर्भरताएँ बहुत ढीली हो सकती हैं। ऑब्जेक्ट सीधे एक दूसरे पर निर्भर नहीं हो सकते हैं और शुद्ध इंटरफेस के माध्यम से एक दूसरे के साथ बातचीत कर सकते हैं। फिर भी इस प्रणाली के बारे में तर्क करना बहुत मुश्किल है, खासकर अगर कुछ गलत हो जाता है, तो बातचीत की जटिल उलझन को देखते हुए। ECS की तुलना में अधिक इंटरैक्शन (अधिक युग्मन, यद्यपि शिथिलता) भी होंगे क्योंकि संस्थाओं को उन घटकों के बारे में जानना होगा जो वे एकत्र करते हैं, भले ही वे एक दूसरे के सार सार्वजनिक इंटरफ़ेस के बारे में जानते हों।
इसके अलावा अगर किसी भी चीज़ में डिज़ाइन में बदलाव होते हैं, तो आपको ईसीएस की तुलना में अधिक कैस्केडिंग ब्रेक मिलते हैं, और आम तौर पर डिज़ाइन में बदलाव के लिए और अधिक कारण और प्रलोभन होंगे क्योंकि हर एक चीज़ एक अच्छी वस्तु-उन्मुख इंटरफ़ेस और अमूर्तता प्रदान करने की कोशिश कर रही है। यह तुरंत इस विचार के साथ आता है कि प्रत्येक और हर एक छोटी सी चीज डिजाइन के लिए बाधाओं और सीमाओं को लागू करने की कोशिश कर रही है, और उन बाधाओं को अक्सर वारंट डिजाइन में बदलाव होता है। कार्यक्षमता बहुत अधिक बाधित है और कच्चे डेटा की तुलना में बहुत अधिक डिजाइन मान्यताओं को बनाना है।
मैंने उपरोक्त प्रकार के "सपाट" ईसीएस प्रणाली के अभ्यास में पाया है कि ढीले निर्भरता के एक जटिल मकड़ी के साथ यहां तक कि सबसे शिथिल-युग्मित प्रणालियों की तुलना में कारण के लिए इतना आसान होना और सबसे महत्वपूर्ण बात, मुझे बहुत कम कारण मिलते हैं ईसीएस संस्करण के लिए कभी भी किसी भी मौजूदा घटकों को बदलने की आवश्यकता होती है क्योंकि घटकों पर निर्भर करने के लिए कोई जिम्मेदारी नहीं होती है सिवाय सिस्टम को कार्य करने के लिए आवश्यक उचित डेटा प्रदान करने के। शुद्ध IMotionइंटरफ़ेस और ठोस गति ऑब्जेक्ट को डिज़ाइन करने की कठिनाई की तुलना उस इंटरफ़ेस को लागू करने में करें जो निजी डेटा पर आक्रमणकारियों को बनाए रखने की कोशिश करते हुए परिष्कृत कार्यक्षमता प्रदान करता है। एक गति घटक जो केवल समस्या को हल करने के लिए प्रासंगिक कच्चे डेटा प्रदान करने की आवश्यकता है और परेशान नहीं करता है कार्यक्षमता।
कार्यक्षमता डेटा की तुलना में सही होने के लिए बहुत कठिन है, यही कारण है कि मुझे लगता है कि डेटा के प्रति निर्भरता के प्रवाह को निर्देशित करना अक्सर बेहतर होता है। आखिरकार, कितने वेक्टर / मैट्रिक्स पुस्तकालय बाहर हैं? उनमें से कितने सटीक समान डेटा प्रतिनिधित्व का उपयोग करते हैं और केवल कार्यक्षमता में समान रूप से भिन्न होते हैं? अनगिनत, और फिर भी हमारे पास समान डेटा अभ्यावेदन के बावजूद अभी भी बहुत सारे हैं क्योंकि हम कार्यक्षमता में सूक्ष्म अंतर चाहते हैं। कितने छवि पुस्तकालय बाहर हैं? उनमें से कितने एक अलग और अनूठे तरीके से पिक्सेल का प्रतिनिधित्व करते हैं? शायद ही कोई हो, और फिर से यह दिखाते हुए कि कार्यक्षमता बहुत अधिक अस्थिर है और कई परिदृश्यों में डेटा की तुलना में डिजाइन परिवर्तनों के लिए प्रवण है। बेशक कुछ बिंदु पर हमें कार्यक्षमता की आवश्यकता है, लेकिन आप उन प्रणालियों को डिज़ाइन कर सकते हैं जहां निर्भरता का थोक डेटा की ओर बहता है: और सामान्य रूप से अमूर्तता या कार्यक्षमता की ओर नहीं। यह युग्मन के ऊपर स्थिरता को प्राथमिकता देगा।
सबसे स्थिर कार्य जो मैंने कभी लिखे हैं (जिस तरह से मैं 80 साल के बाद से उपयोग कर रहा हूं और उन्हें बिना बदले उन्हें बदल रहा हूं) वे सभी थे जो कच्चे डेटा पर निर्भर थे, जैसे कि एक ज्यामिति फ़ंक्शन जो सिर्फ एक सरणी को स्वीकार करता है तैरता और पूर्णांकों, नहीं जो कि एक जटिल पर निर्भर Meshवस्तु या IMeshइंटरफेस, या वेक्टर / मैट्रिक्स गुणा बस पर निर्भर है जो float[]या double[]नहीं एक है कि पर निर्भर FancyMatrixObjectWhichWillRequireDesignChangesNextYearAndDeprecateWhatWeUse।