अमूर्तता के कितने डिजाइन पैटर्न और स्तर आवश्यक हैं? [बन्द है]


29

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

जिन डेवलपर्स के साथ मैं काम करता हूं वे इन बिंदुओं से अलग प्रोग्रामिंग कर रहे हैं।

कुछ हर छोटे कार्य को अमूर्त करते हैं, जहां भी संभव हो डिजाइन पैटर्न का उपयोग करें और किसी भी कीमत पर अतिरेक से बचें।

मेरे सहित अन्य, अधिक व्यावहारिक होने की कोशिश करते हैं, और कोड लिखते हैं जो हर डिज़ाइन पैटर्न को पूरी तरह से फिट नहीं करता है, लेकिन यह समझने के लिए तेज़ है क्योंकि कम अमूर्तता लागू होती है।

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

उदाहरण के लिए, जब एक सामान्य कैशिंग परत को मेमचे का उपयोग करके लिखा गया है। हम वास्तव में जरूरत है Memcache, MemcacheAdapter, MemcacheInterface, AbstractCache, CacheFactory, CacheConnector, ... या इस बनाए रखने के लिए आसान है और अभी भी अच्छे कोड जब उन वर्गों का केवल आधा उपयोग कर रहा है?

ट्विटर में यह पाया:

यहां छवि विवरण दर्ज करें

( https://twitter.com/rawkode/status/875318003306565633 )


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


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

8
कोई रास्ता नहीं है एक एसई उत्तर संभवतः इस विषय को पर्याप्त रूप से कवर कर सकता है। यह वस्तुतः वर्षों का अनुभव लेता है और इसे संभालने के लिए सलाह देता है। यह स्पष्ट रूप से बहुत व्यापक है।
jpmc26

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

जवाबों:


52

भोजन के लिए कितनी सामग्री आवश्यक है? वाहन बनाने के लिए आपको कितने भागों की आवश्यकता होती है?

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

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

इसके अलावा, वास्तव में नंबर देकर सवाल का जवाब देने का कोई तरीका नहीं है। अमूर्त की संख्या एक परियोजना से दूसरी परियोजना के लिए, एक भाषा से दूसरी में, और यहां तक ​​कि एक डेवलपर से दूसरे में भी समान नहीं होगी।


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

अमूर्त की संख्या भी एक ही परियोजना के विभिन्न भागों के लिए समान नहीं होगी!
टी। सर -

संकेत: मेमेचे से दूसरे कैशिंग तंत्र (रेडिस?) में परिवर्तन एक कार्यान्वयन परिवर्तन है।
ओगरे Psalm33

ट्यूलेंस द्वारा प्रदर्शित आपके दो नियम (दिशानिर्देश, जो भी आप उन्हें कॉल करना चाहते हैं) काम नहीं करते हैं। वे भले ही कितने भी अधूरे क्यों न हों। बाकी की पोस्ट एक गैर-उत्तर है, यह कहते हुए कि हम यथोचित रूप से स्कोप किए गए उत्तर प्रदान नहीं कर सकते हैं। -1
jpmc26

मेरा तर्क है कि दो इंटरफेस और उन्हें लागू करने वाले सैकड़ों वर्गों के मामले में, आपने संभवतः अपने अमूर्तता को खत्म कर दिया है। मैंने निश्चित रूप से इसे उन परियोजनाओं में देखा है जो कई स्थानों ( interface Doer {void prepare(); void doIt();}) में एक बहुत अस्पष्ट अमूर्तता का पुन: उपयोग करते हैं , और जब यह अमूर्त अब फिट नहीं होता है तो यह रिफलेक्टर के लिए दर्दनाक हो जाता है। उत्तर का मुख्य भाग यह है कि परीक्षण तब लागू होता है जब एक अमूर्त को बदलना पड़ता है - यदि यह कभी नहीं करता है, तो यह कभी दर्द का कारण नहीं बनता है।
जेम्स_पिक

24

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

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

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

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


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

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

मैं अपने अखरोट खुर के लिए प्रशिक्षित गिलहरी की एक सेना चाहता हूं।
icc97

6

टी एल: डॉ;

मुझे नहीं लगता कि गर्भपात के स्तर की कोई "आवश्यक" संख्या है जिसके नीचे बहुत कम या बहुत अधिक है। ग्राफिक डिजाइन के रूप में, अच्छा ओओपी डिजाइन अदृश्य होना चाहिए और इसे दी जानी चाहिए। खराब डिजाइन हमेशा एक गले में अंगूठे की तरह बाहर रहता है।

लंबा जवाब

सबसे शायद आप कभी नहीं जान पाएंगे कि आप कितने स्तर के गर्भपात कर रहे हैं।

अमूर्तता के अधिकांश स्तर हमारे लिए अदृश्य हैं और हम उन्हें प्रदान करते हैं।

यही तर्क मुझे इस निष्कर्ष पर पहुंचाता है:

अमूर्तता का एक मुख्य उद्देश्य प्रोग्रामर को हर समय सिस्टम की सभी कार्यप्रणाली को ध्यान में रखना आवश्यक है। यदि डिज़ाइन आपको कुछ जोड़ने के लिए सिस्टम के बारे में बहुत अधिक जानने के लिए मजबूर करता है तो संभवतः बहुत कम अमूर्तता है। मुझे लगता है कि बुरा अमूर्त (खराब डिजाइन, एनीमिक डिजाइन या ओवर-इंजीनियरिंग) भी आपको कुछ जोड़ने के लिए बहुत अधिक जानने के लिए मजबूर कर सकता है। एक चरम में हमारे पास एक ईश्वर वर्ग या DTO के झुंड पर आधारित एक डिज़ाइन है, दूसरे चरम में हमारे पास कुछ OR / दृढ़ता फ्रेमवर्क हैं जो आपको हेल्लो वर्ल्ड प्राप्त करने के लिए बेशुमार हुप्स के माध्यम से कूदने के लिए बनाते हैं। दोनों मामले आपको बहुत ज्यादा जानते हैं।

बुरा अमूर्तता इस तथ्य में गॉस की घंटी का पालन करती है कि एक बार जब आप रास्ते में प्राप्त करने के लिए शुरू करते हैं, तो एक मीठी जगह का निर्माण करते हैं। दूसरे हाथ में अच्छा अमूर्त, अदृश्य है और इसमें बहुत अधिक नहीं हो सकता क्योंकि आप इसे नोटिस नहीं करते हैं। APIs, नेटवर्क प्रोटोकॉल, लाइब्रेरी, OS लाइब्रेरी, फाइल सिस्टम, हार्बर लेयर्स इत्यादि की परतों पर कितनी परतें हैं, इस बारे में सोचें कि आपका एप्लिकेशन किस आधार पर बनाया गया है और किसके लिए है।

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


2
"ज्यादातर शायद आपको कभी पता नहीं चलेगा कि आप कितने स्तर के गर्भपात कर रहे हैं।" - वास्तव में, एक अमूर्तता का पूरा बिंदु यह है कि आप नहीं जानते कि इसे कैसे लागू किया जाता है, IOW आप नहीं (और नहीं कर सकते ) यह जानते हैं कि यह कितने स्तरों पर छुपा है।
जॉर्ज डब्ल्यू मित्तग

4

डिज़ाइन पैटर्न केवल समस्याओं का सामान्य समाधान है। डिजाइन पैटर्न जानना महत्वपूर्ण है, लेकिन वे केवल अच्छी तरह से डिज़ाइन किए गए कोड के लक्षण हैं (अच्छा कोड अभी भी डिजाइन पैटर्न के चार सेट के गिरोह से शून्य हो सकता है ), कारण नहीं।

सार बाड़ की तरह हैं। वे आपके प्रोग्राम के अलग-अलग क्षेत्रों को परीक्षण करने योग्य और विनिमेय विखंडू (गैर-नाजुक गैर-कठोर कोड बनाने की आवश्यकता) में मदद करते हैं। और बहुत कुछ बाड़ की तरह:

  • आप प्राकृतिक इंटरफ़ेस बिंदुओं पर उनके आकार को कम करने के लिए सार चाहते हैं।

  • आप उन्हें बदलना नहीं चाहते हैं।

  • आप चाहते हैं कि वे उन चीजों को अलग करें जो स्वतंत्र हो सकती हैं।

  • गलत जगह पर एक होने के लिए नहीं होने से भी बदतर है।

  • उनके पास बड़ी लीक नहीं होनी चाहिए ।


4

पुनर्रचना

मैंने अब तक एक बार भी उल्लेखित शब्द "रीफैक्टरिंग" नहीं देखा। तो अब हम शुरू करें:

संभव के रूप में सीधे एक नई सुविधा को लागू करने के लिए स्वतंत्र महसूस करें। यदि आपके पास केवल एकल, सरल, वर्ग है, तो आपको इसके लिए एक इंटरफ़ेस, एक सुपरक्लास, एक कारखाने आदि की आवश्यकता नहीं है।

अगर और जब आप नोटिस करते हैं कि आप कक्षा का विस्तार इस तरह से करते हैं कि यह बहुत मोटा हो जाता है, तो इसे अलग करने का समय है। उस समय यह सोचने में बहुत परेशानी होती है कि आपको वास्तव में ऐसा कैसे करना चाहिए।

पैटर्न एक माइंड टूल है

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

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

पुस्तकालय

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


2

अमूर्तता का बिंदु पहले होना चाहिए और उस मूल्य को अलग करना चाहिए जो अमूर्त के उपभोक्ता को लाया जाता है, अर्थात अमूर्त ग्राहक, अन्य प्रोग्रामर और अक्सर स्वयं।

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

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

खपत करने वाले प्रोग्रामर के लिए सार के मूल्य पर विचार करने के बाद, फिर हम मूल्यांकन और कार्यान्वयन पर विचार कर सकते हैं, जैसे कि DRY-ness।

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


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

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


2

Abstraction को समझने के लिए कोड को आसान बनाने के लिए डिज़ाइन किया गया है। अगर अमूर्त की एक परत चीजों को और अधिक भ्रमित करने वाली है - ऐसा मत करो।

उद्देश्य सही संख्या के सार और इंटरफेस का उपयोग करना है:

  • विकास का समय कम से कम करें
  • अधिकतम कोड स्थिरता

आवश्यकता पड़ने पर ही सार

  1. जब आपको पता चलता है कि आप एक सुपर क्लास लिख रहे हैं
  2. जब यह महत्वपूर्ण कोड को फिर से उपयोग करने की अनुमति देगा
  3. तो सार संक्षेप कोड कर देगा हो जाएगा काफी स्पष्ट और पढ़ने में आसान

जब सार न हो

  1. ऐसा करने से कोड-पुन: उपयोग या स्पष्टता में लाभ नहीं होगा
  2. ऐसा करने से कोई लाभ नहीं होने के साथ कोड काफी लंबा / अधिक जटिल हो जाएगा

कुछ उदाहरण

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

2

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

डिजाइन पैटर्न का उपयोग करने के तरीके के साथ समस्या यह है कि जब उन्हें सिखाया जाता है, तो वे इस तरह से एक मामला पेश करते हैं:

आपके पास यह विशिष्ट परिदृश्य है। अपने कोड को इस तरह व्यवस्थित करें। यहाँ एक स्मार्ट-दिखने वाला है, लेकिन कुछ हद तक इसका उदाहरण है।

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

इसके अलावा, मैं आंद्रेई अलेक्जेंड्रेस्कु को उद्धृत करना चाहूंगा, जब सॉफ्टवेयर इंजीनियरिंग के बारे में बात कर रहा हूं, जो बताता है:

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

शायद यह थोड़ा अतिशयोक्ति है, लेकिन मुझे लगता है कि यह पूरी तरह से एक अतिरिक्त कारण बताता है कि आप अपने कोड में कम आत्मविश्वास क्यों महसूस कर सकते हैं।

यह इस तरह से है कि माइक एक्टन की भविष्यद्वाणी की आवाज, इंसोम्नियाक में गेम इंजन लीड, मेरी आवाज में चिल्लाती है:

अपना डेटा पता है

वह आपके प्रोग्राम के इनपुट्स और वांछित आउटपुट के बारे में बात कर रहा है। और फिर यह पौराणिक मानव माह से फ्रेड ब्रूक्स मणि है:

मुझे अपनी फ़्लोचार्ट दिखाओ और अपनी टेबल छुपाओ, और मैं रहस्यमयी बना रहूँगा। मुझे अपनी टेबल दिखाओ, और मुझे आमतौर पर आपके फ्लोचार्ट की आवश्यकता नहीं होगी; वे स्पष्ट हो जाएंगे।

इसलिए अगर मैं आप थे, तो मैं अपने ठेठ इनपुट मामले के आधार पर अपनी समस्या के बारे में बताऊंगा, और क्या यह वांछित सही आउटपुट प्राप्त करता है। और इस तरह के प्रश्न पूछें:

  • क्या मेरे प्रोग्राम से आउटपुट डेटा सही है?
  • क्या यह मेरे सबसे सामान्य इनपुट केस के लिए कुशलतापूर्वक / जल्दी से निर्मित है?
  • क्या मेरा कोड मेरे और मेरे साथियों दोनों के लिए स्थानीय स्तर पर काफी आसान है? यदि नहीं, तो क्या मैं इसे सरल बना सकता हूं?

जब आप ऐसा करते हैं, तो "अमूर्त या डिजाइन पैटर्न की कितनी परतों की आवश्यकता है" का सवाल जवाब देने में बहुत आसान हो जाता है। अमूर्त की कितनी परतों की आवश्यकता है? इन लक्ष्यों को प्राप्त करने के लिए जितना आवश्यक है, उतना नहीं। "डिजाइन पैटर्न के बारे में क्या? मैंने कोई उपयोग नहीं किया है!" ठीक है, अगर पैटर्न के प्रत्यक्ष आवेदन के बिना उपरोक्त लक्ष्यों को प्राप्त किया गया था, तो यह ठीक है। इसे काम करें, और अगली समस्या पर जाएं। अपने डेटा से प्रारंभ करें, कोड से नहीं।


2

सॉफ्टवेयर वास्तुकला भाषाओं का आविष्कार है

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

वास्तुकला के मुद्दों पर निर्णय लेते समय यह दृश्य मेरी मदद करता है।

पठनीयता

उस भाषा को आसानी से समझा जाना चाहिए (अगली परत के कोड को पठनीय बनाना)। कोड लिखित की तुलना में कहीं अधिक बार पढ़ा जाता है।

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

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

प्रयोज्य

भाषा का उपयोग करना आसान होना चाहिए ("सही वाक्य" तैयार करना आसान है)।

अगर ये सभी MemCache कक्षाएं / इंटरफेस अगली परत के लिए दृश्यमान हो जाते हैं, जो उपयोगकर्ता के लिए एक कठिन सीखने की अवस्था बनाता है जब तक कि वह समझता है कि कैश की एकल अवधारणा के लिए इन शब्दों में से कब और कहां उपयोग करना है।

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

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

सारांश

यदि उपयोग को आसान बनाता है, तो अमूर्तता का परिचय दें (और अमूर्त और कार्यान्वयन दोनों को बनाए रखने के ओवरहेड के लायक है)।

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


1

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

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


-1

सबसे पहले, ट्विटर उद्धरण फर्जी है। नए डेवलपर्स को एक मॉडल बनाने की ज़रूरत है, अमूर्तता आमतौर पर उन्हें "चित्र प्राप्त करने" में मदद करेगी। बशर्ते अमूर्तता का बोध हो।

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


2
आइए "अनुभव" के रूप में अनुभव को खारिज करने से बचना चाहिए। बहुत सारे अमूर्त एक वास्तविक समस्या हैं। अफसोस की बात है कि लोग एक वास्तविक समस्या को हल करने के बजाय "सबसे अच्छा अभ्यास" करते हैं, क्योंकि यह सबसे अच्छा है। इसके अलावा, कोई भी "इन चीजों के बारे में" तय नहीं कर सकता है ... लोग कंपनियों को छोड़ देते हैं, लोग जुड़ते हैं, कोई भी अपनी कीचड़ का स्वामित्व नहीं लेता है।
रावकोड Raw
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.