कोड का पुन: उपयोग एक बहुत अच्छा विचार है। महान नहीं है ।
मेरे पास लगभग 30 वर्षों के सॉफ़्टवेयर इंजीनियरिंग का एक दृष्टिकोण है, जो "पुन: उपयोग" करने की कोशिश कर रहा है।
मैंने 80 के दशक में एक शोध विषय के रूप में "कोड पुन: उपयोग" की जांच शुरू कर दी थी, मुझे पता चला कि मैंने 70 के दशक के शुरुआती दिनों में बनाए गए एक ओएस के डिजाइन का पुन: उपयोग किया था, दूसरे ओएस के लिए मैंने 70 के दशक के अंत में बनाया था।
कोड के पुन: उपयोग का अच्छा हिस्सा कभी-कभी ईमानदार-से-ईश्वर के लिए कोड का पुन: उपयोग करने की क्षमता है। लेकिन दुनिया कोड से भरी है; आप जो चाहते हैं वह कैसे पा सकते हैं? यहाँ मैं क्या पुनः प्रयोग अभिशाप कहते हैं :
मैं सांता क्लॉस (ओके ओपन सोर्स) हूं, और मेरे पास 1 बिलियन सॉफ्टवेयर घटकों का एक बैग है। आपके पास उनमें से कोई भी हो सकता है।
सौभाग्य का चयन।
पुन: उपयोग की समस्या को अच्छी तरह से हल करने के लिए:
- पुनरावर्ती को किसी तरह यह निर्दिष्ट करने की आवश्यकता है कि उसे क्या ज़रूरत है (कार्यात्मकता, प्रदर्शन, लक्ष्य भाषा, पर्यावरण मान्यताओं, ...)
- "पुन: प्रयोज्य" कोड का एक पुस्तकालय होना चाहिए जिसे इन संभावित मानदंडों द्वारा विभिन्न तरीकों से अनुक्रमित किया गया है
- उम्मीदवार तंत्र को निकालने के लिए कुछ तंत्र मौजूद होना चाहिए (एक अरब तत्वों पर, आप उन सभी को व्यक्तिगत रूप से नहीं देख सकते हैं)
- चुने गए उम्मीदवारों के विनिर्देश से कितनी दूर हैं, इसके लिए चरित्रवान होने की जरूरत है
- पुन: उपयोग करने के लिए पुन: प्रयोज्य कोड को संशोधित करने की अनुमति देने के लिए कुछ नियमित प्रक्रिया मौजूद होनी चाहिए (यहां ओओपी का सबसे बड़ा योगदान है: आप किसी मौजूदा घटक / वस्तु को उसके स्लॉट को ओवरराइड करके संपादित कर सकते हैं। ओओपी कोई अन्य सहायता प्रदान नहीं करता है)।
- यह सब स्पष्ट रूप से इसे फिर से भरने की तुलना में सस्ता होना चाहिए
ज्यादातर वर्षों में जो खोजा गया है वह यह है कि कोड को पुन: प्रयोज्य होने के लिए, इसे उस उद्देश्य के लिए डिज़ाइन किया जाना चाहिए, या इसमें बहुत अधिक निहितार्थ भी शामिल हैं। सबसे सफल कोड पुन: उपयोग पुस्तकालयों वास्तव में बहुत छोटा हो गया है। संभवतः पुस्तकालय और रूपरेखा "पुन: प्रयोज्य" कोड हैं और वे बेहद सफल हैं; जावा और सी # सफल नहीं हैं क्योंकि वे बहुत अच्छी कंप्यूटर भाषा हैं, बल्कि इसलिए कि उनके पास बहुत अच्छी तरह से डिजाइन, कार्यान्वित और प्रलेखित पुस्तकालय उपलब्ध हैं। लेकिन लोग पुस्तकालयों में स्रोत कोड को नहीं देखते हैं; वे बस एक अच्छी तरह से प्रलेखित एपीआई (आमतौर पर प्रयोग करने योग्य बनाया गया) कहते हैं।
कोड पुन: उपयोग नहीं किया है (OOP न तो) कोड प्रणालियों के लिए हमारी क्षमता में परिमाण सुधार के आदेश प्रदान करता है।
मुझे लगता है कि मुख्य दोष यह है कि किसी भी प्रकार का कोड पुन: उपयोग मौलिक रूप से सीमित है क्योंकि कोड में बहुत अधिक धारणाएं हैं । यदि आप कोड को छोटा करते हैं, तो आप मान्यताओं को कम कर देते हैं, लेकिन फिर स्क्रैच से निर्माण करने की लागत बहुत बड़ी नहीं होती है और पुन: उपयोग प्रभावी नहीं होता है। यदि आप कोड को विशाल बनाते हैं, तो वे एक नए संदर्भ में बहुत बेकार हैं। गुलिवर की तरह, वे एक लाख छोटे तारों से समुद्र तट से बंधे हैं, और आप बस उन सभी को काटने का जोखिम नहीं उठा सकते हैं।
हमें जिस चीज पर काम करना चाहिए वह कोड के निर्माण के लिए ज्ञान का पुन: उपयोग है । यदि हम ऐसा कर सकते हैं, तो हम उस ज्ञान को उस कोड के निर्माण के लिए लागू कर सकते हैं जिसकी हमें ज़रूरत है, मान्यताओं के वर्तमान सेट को संभालना।
ऐसा करने के लिए, किसी को अभी भी सॉफ्टवेयर घटकों को चिह्नित करने के लिए समान विनिर्देश क्षमता की आवश्यकता है (आपको अभी भी कहना है कि आप क्या चाहते हैं!)। लेकिन फिर आप इस "निर्माण" ज्ञान को उन विशिष्टताओं पर लागू करते हैं जो आप चाहते हैं कि कोड उत्पन्न करें।
एक समुदाय के रूप में, हम अभी तक इस पर बहुत अच्छे नहीं हैं। लेकिन लोग इसे हर समय करते हैं; हम इसे स्वचालित क्यों नहीं कर सकते? बहुत सारे शोध हैं, और इससे पता चलता है कि यह कई परिस्थितियों में किया जा सकता है।
इसके लिए आवश्यक मशीनरी का एक महत्वपूर्ण टुकड़ा "घटक विवरण" को स्वीकार करने के लिए यांत्रिक उपकरण हैं (ये सिर्फ औपचारिक दस्तावेज हैं और प्रोग्रामिंग भाषाओं की तरह पार्स किए जा सकते हैं) और उनके लिए कार्यक्रम परिवर्तनों को लागू करें।
कंपाइलर पहले से ही ऐसा करते हैं: -} और वे वास्तव में उस समस्या के वर्ग में अच्छे हैं जिससे वे निपटते हैं।
कोड पीढ़ी वाले UML मॉडल ऐसा करने का एक प्रयास है। बहुत अच्छा प्रयास नहीं; अधिकांश यूएमएल मॉडल में बहुत कुछ जो कहता है वह है "मेरे पास डेटा है जो इस तरह दिखता है"। अगर कार्यक्षमता को छोड़ दिया जाए तो एक वास्तविक कार्यक्रम तैयार करना बहुत कठिन है।
मैं व्यावहारिक प्रोग्राम ट्रांसफ़ॉर्मेशन सिस्टम बनाने का प्रयास कर रहा हूँ , एक उपकरण जिसे डीएमएस कहा जाता है । कोड को उत्पन्न करने के लिए अमूर्त विनिर्देशों के लिए कार्यक्रम परिवर्तनों को लागू करने के लिए बहुत अच्छी तरह से विचलित नहीं किया गया है, बल्कि इसे साफ करने के लिए विरासत कोड के लिए। (ये सार में एक ही समस्या है!)। (इस तरह के उपकरण बनाने में बहुत समय लगता है; मैं 15 साल से ऐसा कर रहा हूं और इस दौरान आपको खाना खाना होगा)।
लेकिन डीएमएस के पास ऊपर वर्णित दो प्रमुख गुण हैं: मनमाने ढंग से औपचारिक विनिर्देशों को संसाधित करने की क्षमता, और "कोड पीढ़ी के ज्ञान" को रूपांतरित करने की क्षमता, और उन्हें मांग पर लागू करने की क्षमता। और उल्लेखनीय रूप से, हम कुछ विशेष मामलों में उत्पन्न करते हैं, कुछ विशिष्ट विनिर्देशों से दिलचस्प कोड; इसका कार्यान्वयन उत्पन्न करने के लिए डीएमएस का उपयोग बड़े पैमाने पर किया जाता है। यह हमारे (ज्ञान) पुन: उपयोग के कम से कम कुछ वादों के लिए हासिल किया गया है: अत्यंत महत्वपूर्ण उत्पादकता लाभ। मेरे पास लगभग 7 तकनीकी लोगों की एक टीम है; हमने शायद डीएमएस के लिए "विनिर्देशों" के 1-2 एमएसएलओसी लिखे हैं, लेकिन कुछ 10MSLOC उत्पन्न कोड हैं।
सारांश: पीढ़ी के ज्ञान का पुन : उपयोग जीत है, कोड का पुन: उपयोग नहीं ।