यह एक अस्पष्ट प्रश्न है, लेकिन यह कुछ ऐसा है जिसे मैंने कभी महसूस नहीं किया है जब उचित डिजाइन के बारे में पढ़कर संतोषजनक तरीके से उत्तर दिया गया हो।
आम तौर पर, जब ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग, एब्सट्रैक्शन, फैक्टरिंग आउट, इत्यादि के बारे में सीखते हैं, तो डिज़ाइन के पवित्र ग्रिल - और वे हमेशा दावा करते हैं कि आप प्रश्न में विकास तकनीकों का उपयोग कर रहे हैं - यह है कि यह आपके प्रोग्राम को "बदलने में आसान" बना देगा , "बनाए रखने योग्य", "लचीला", या इस तरह के उत्पादक-लगने वाली अवधारणा को व्यक्त करने के लिए इस्तेमाल किए गए किसी भी पर्यायवाची। आइवर को निजी, कई छोटे, स्व-निहित तरीकों में कोड को विभाजित करके, इंटरफेस को सामान्य रखते हुए, आप आसानी से और आसानी से अपने कार्यक्रम को संशोधित करने की क्षमता प्राप्त करते हैं।
अपेक्षाकृत छोटे बदलावों के लिए, इसने मेरे लिए अच्छा काम किया है। प्रदर्शन को बढ़ाने के लिए एक वर्ग द्वारा उपयोग किए जाने वाले आंतरिक डेटा संरचनाओं में परिवर्तन कभी भी एक बड़ी कठिनाई नहीं रही है, और न ही उपयोगकर्ता-इंटरफ़ेस के अंत में परिवर्तन हुए हैं, एपीआई से स्वतंत्र, जैसे कि एक पाठ प्रविष्टि प्रणाली को फिर से डिज़ाइन करना या गेमप्ले तत्व के लिए ग्राफिक्स को ओवरहाल करना। ।
ये सभी परिवर्तन स्वाभाविक रूप से आत्म-निहित लगते हैं। उनमें से कोई भी आपके कार्यक्रम के घटक के व्यवहार या डिजाइन में कोई बदलाव नहीं करता है, संशोधित किया जा रहा है, जहां तक बाहरी कोड से संबंधित है। चाहे आप प्रक्रियात्मक रूप से लिख रहे हों या ओओ शैली में, बड़े कार्यों या छोटे के साथ, ये आसान बदलाव हैं भले ही आपके पास केवल एक अच्छा डिज़ाइन हो।
हालांकि, जब भी परिवर्तन बड़े और बालों वाले होते हैं - अर्थात, एपीआई में परिवर्तन - मेरे कीमती "पैटर्न" में से कोई भी कभी बचाव में नहीं आता है। बड़ा परिवर्तन बड़ा रहता है, प्रभावित कोड प्रभावित रहता है, और बग-स्पोविंग कार्य के कई घंटे मेरे आगे पड़े रहते हैं।
तो मेरा सवाल ये है। कितना बड़ा बदलाव उचित डिज़ाइन दावा करने में सुविधा प्रदान करने में सक्षम है? क्या कुछ और डिज़ाइन तकनीक है, जो या तो मेरे लिए अज्ञात है या जिसे मैं कार्यान्वित करने में विफल रहा हूं, जो वास्तव में चिपचिपा-ध्वनि संशोधन को सरल बनाता है, या क्या वह वादा है (जो मैंने इतने अलग-अलग प्रतिमानों द्वारा सुना है) केवल एक अच्छा विचार है, पूरी तरह से सॉफ्टवेयर विकास के अपरिवर्तनीय सत्य से डिस्कनेक्ट किया गया? क्या कोई "परिवर्तन उपकरण" है जिसे मैं अपने टूलबेल में जोड़ सकता हूं?
विशेष रूप से, जिस समस्या का मुझे सामना करना पड़ रहा है वह मुझे मंचों पर ले जा रहा है यह है: मैं एक व्याख्या की गई प्रोग्रामिंग भाषा को लागू करने पर काम कर रहा हूं (डी में लागू किया गया है, लेकिन यह प्रासंगिक नहीं है), और मैंने फैसला किया है कि मेरे करीबी तर्क होने चाहिए कीवर्ड-आधारित, स्थिति के बजाय वर्तमान में जैसे वे हैं। इसके लिए सभी मौजूदा कोड को संशोधित करने की आवश्यकता होती है जो गुमनाम कार्यों को कहते हैं, जो सौभाग्य से, बल्कि इसलिए छोटा है क्योंकि मैं अपनी भाषा के विकास (<2000 लाइनों) पर जल्दी हूं, लेकिन अगर मैं बाद के चरण में यह निर्णय लेता हूं तो यह बहुत बड़ा होगा। ऐसी स्थिति में, क्या ऐसा कोई तरीका है कि डिजाइन में उचित दूरदर्शिता से मैं इस संशोधन को आसान बना सकता हूं, या कुछ (अधिकांश) आंतरिक रूप से दूरगामी परिवर्तन कर रहे हैं? मैं उत्सुक हूँ अगर यह किसी भी तरह से अपने स्वयं के डिजाइन कौशल की विफलता है - अगर यह है, तो मैं '
स्पष्ट होने के लिए, मैं आमतौर पर उपयोग में ओओपी या किसी अन्य पैटर्न से किसी भी तरह का संदेह नहीं करता हूं। मेरे लिए, हालांकि, उनके गुण मूल लेखन में हैं, कोड आधारों के रखरखाव के बजाय। वंशानुक्रम आपको दोहराए गए पैटर्न को अच्छी तरह से अमूर्त करने की अनुमति देता है, बहुरूपता आपको मशीन-डीम्ड प्रभाव ( switchबयान की कौन सी शाखा) के बजाय मानव-समझे गए फ़ंक्शन (कौन सी कक्षा) द्वारा अलग-अलग कोड की अनुमति देता है , और छोटे, स्व-निहित आपको आपको अनुमति देता है एक बहुत ही सुखद "नीचे-ऊपर" शैली में लिखें। हालांकि, मुझे लचीलेपन के उनके दावों पर संदेह है।
foo metarg1: bar metarg2: bazके रूप में foo.metarg1_metarg2_(bar, baz)। हालाँकि, मेरी भाषा एक बड़ा बदलाव कर रही है, अर्थात् सूची आधारित मापदंडों को शब्दकोश आधारित मापदंडों के लिए, जो रनटाइम को प्रभावित करता है लेकिन पार्सर को नहीं , वास्तव में, मेरी भाषा के विशिष्ट गुणों के कारण मैं अभी इसमें नहीं जाऊंगा। चूंकि अनियंत्रित-कीवर्ड और स्थिति संबंधी तर्कों के बीच कोई स्पष्ट मानचित्रण नहीं है, इसलिए रनटाइम मुख्य मुद्दा है।