आप कितनी सख्ती से "नो डिपेंडेंसी साइकल" नियम (एनडीपीडी) का पालन करते हैं

10

पृष्ठभूमि की एक बिट: एक टीम के नेतृत्व के रूप में मैं हमारे कोड की गुणवत्ता की जांच के लिए सप्ताह में एक बार एनडीपीएन का उपयोग करता हूं। विशेष रूप से परीक्षण-कवरेज, कोड की लाइनें और चक्रवाती जटिलता मैट्रिक्स मेरे लिए अमूल्य हैं। लेकिन जब यह स्तर और निर्भरता चक्र के नीचे आता है तो मैं थोड़ा ... अच्छी तरह से चिंतित हूं। पैट्रिक स्मैचिया के पास एक अच्छा ब्लॉग पोस्ट है जो समतलन के लक्ष्य का वर्णन करता है।

स्पष्ट होने के लिए: "निर्भरता चक्र" के तहत मैं दो नामस्थानों के बीच एक परिपत्र संदर्भ समझता हूं।

वर्तमान में मैं एम्बेडेड इंस्ट्रूमेंट्स के लिए विंडोज सीई आधारित जीयूआई फ्रेमवर्क पर काम कर रहा हूं - बस एंड्रॉइड ग्राफिक्स प्लेटफॉर्म के बारे में सोचें, लेकिन बहुत कम एंड इंस्ट्रूमेंट्स के लिए। फ्रेमवर्क एक एकल असेंबली है जिसमें कोड की 50.000 लाइनें (परीक्षण बाहर किए गए) हैं। रूपरेखा को निम्नलिखित नामस्थानों में विभाजित किया गया है:

कोर नेविगेशन और मेनू सबसिस्टम
स्क्रीन सबसिस्टम (प्रस्तुतकर्ता / दृश्य / ...)
नियंत्रण / विजेट परत

आज मैंने आधे दिन कोड को उचित स्तरों पर लाने की कोशिश में बिताए [सामान्य में कोई समस्या नहीं है] के लिए धन्यवाद, लेकिन सभी मामलों में कुछ निर्भरता चक्र मौजूद हैं।

तो मेरा सवाल: आप "नो डिपेंडेंसी साइकिल" नियम का कितनी सख्ती से पालन करते हैं? क्या स्तरीकरण वास्तव में महत्वपूर्ण है?

code-quality

— ollifant
स्रोत

2

यदि "कोई निर्भरता चक्र" का अर्थ कोई परिपत्र संदर्भ नहीं है, तो - कोई बहाना नहीं। वे शुद्ध दुष्ट हैं।

— अर्निस लैप्सा

@ollifant: "नो डिपेंडेंसी साइकिल" लिखते समय आप जो कहते हैं उसका सही मतलब परिभाषित करें। परतों के बीच या एक परत के भीतर कक्षाओं के बीच?

— डॉक ब्राउन

9

मैंने हाल ही में 2 सफ़ेद किताबें लिखी हैं, जो कि आर्किटेक्चर .NET कोड के विषय में सिम्पल-टॉक पर प्रकाशित हुई है (पहली पुस्तक .NET असेंबली के बारे में है, दूसरा नाम स्थान और स्तर के बारे में):

.NET असेंबली और विजुअल स्टूडियो प्रोजेक्ट्स के माध्यम से अपने कोड बेस का विभाजन

नाम घटकों के साथ .NET घटकों को परिभाषित करना

क्या स्तरीकरण वास्तव में महत्वपूर्ण है?

हाँ यही है!

दूसरी सफेद किताब का उद्धरण:

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

(...)

जब तक चक्रीय घटकों की कमी का लगातार सम्मान किया जाता है, तब तक कोड आधार अत्यधिक सीखने योग्य और बनाए रखने योग्य होता है।

पारंपरिक भवन वास्तुकला में, गुरुत्वाकर्षण शक्ति ने निम्न स्तर की कलाकृतियों पर दबाव डाला। यह उन्हें और अधिक स्थिर बनाता है: 'स्थिर' इस अर्थ में कि उन्हें स्थानांतरित करना कठिन है।

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

— पैट्रिक स्मैचिया - एनडिपेंडेंट देव
स्रोत

6

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

कोडिंग परीक्षण-पहले परिपत्र निर्भरताओं को पेश करना मुश्किल बनाता है।

— केविन क्लाइन
स्रोत

4

यह हमेशा एक व्यापार है: आपको यह समझने के लिए निर्भरता की लागत को समझना होगा कि निर्भरता से क्यों बचा जाए। उसी तरह, यदि आप एक निर्भरता की लागत को समझते हैं, तो आप बेहतर तरीके से तय कर सकते हैं कि यह आपके विशिष्ट मामले में लायक है या नहीं।

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

अगर आपको समझ में आ रहा है कि आपके सॉफ्टवेयर को चलाने में अड़चनें हैं (हार्डवेयर, OS, या सिर्फ डिज़ाइन होना चाहिए (जैसे "सरल यूआई हम कर सकते हैं")) तो यह समझना आसान होना चाहिए कि विच निर्भरताएं नहीं होनी चाहिए और जो एक हैं ठीक।

लेकिन अगर आपके पास एक अच्छा और स्पष्ट कारण नहीं है, तो किसी भी निर्भरता से बचें जो आप कर सकते हैं। निर्भर कोड डिबग-सत्र का नरक है।

— Klaim
स्रोत

2

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

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

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

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

— ब्रेंट एरियस
स्रोत

0

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

— रॉबिन ग्रीन
स्रोत