वाणिज्यिक सॉफ्टवेयर विकास में "फूला हुआ कोड"

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

सिस्टम और उनके आकारों की संख्या में वृद्धि के साथ, पैटर्न में थोड़े से बदलाव के साथ, आपको कोड को दिए गए पैटर्न में लाने के लिए स्थानों का एक गुच्छा रिफ्लेक्टर करना होगा।

जेवीएम पर वैकल्पिक भाषाओं की खोज के बाद, हम क्लोजर पर बस गए। इस पर एक त्रुटि हैंडलिंग पैटर्न को लागू करने का एक छोटा सा उदाहरण है।

मान लें कि हम जावा में त्रुटि हैंडलिंग को प्रारूपित करते हैं:

कोशिश करो {
... काम ...
} पकड़ ( आंतरिक अपवाद ई ) {
exceptionHelper। addGroup ( e, TestTest। वर्ग । getName ) ( ) , "... त्रुटि ..." ,
नई जोड़ी ( "परम 1" , परम 1 ) ;
नई जोड़ी ( "परम 2" , परम 2 ) ) ;
ई फेंक दो ;
} पकड़ ( अपवाद ई ) {
अपवाद फेंक । जनरेट करें ( ErrorRef। SYSTEM_ERROR , "... त्रुटि ..." ,
नई जोड़ी ( "परम 1" , परम 1 ) ;
नई जोड़ी ( "परम 2" , परम 2 ) ;
नई जोड़ी ( "अपवाद" , MySerialization; अपवादट्रीस्ट्रिंग ( ई ) ) ) ;
}
}

क्लोजर पर , हैंडलर-यानी मैक्रो को संबंधित लाइब्रेरी में लागू किया गया था, जो इस पैटर्न के तर्क को लागू करता है। उदाहरण के लिए, मध्य फ़ंक्शन में, हम इस मैक्रो का उपयोग करके कॉल को निचले फ़ंक्शन पर संसाधित करते हैं:

( बीच में अवहेलना [ एक बी ]
( यानी / हैंडलर-यानी यानी / सिस्टम-टेस्ट "मध्य स्तर की प्रोसेसिंग" nil [ a b ]
( दो [ परिणाम ( नीचे एक बी ) ]
परिणाम ) ) )

आइए देखें कि संकलन समय में फ़ंक्शन बॉडी कोड का विस्तार क्या है:

( मैक्रोएक्सपैंड- 1 ' ( यानी / हैंडलर-यानी / सिस्टम-टेस्ट "मध्य स्तर प्रसंस्करण" नील [ एक बी ]
( दो [ परिणाम ( नीचे एक बी ) ]
परिणाम ) ) )

परिणाम (ऑटो चर के लिए प्रत्यय और पठनीयता के लिए हटाए गए पूर्ण नामस्थान):

( let [ params ( उल्टा ( zipmap) ( नक्शा str ' [ a b ] ))
[ ख ]] )
त्रुटि-स्थान ( वर्तमान-फ़ंक्शन- नाम ) ]
( कोशिश करो ( परिणाम [ एक बी नीचे ) ]
परिणाम )
( एरर पकड़ें । इकाइयाँ । इंटेलीलेक्सेप्शन ई
( ऐड-ग्रुप-टू-ई-ई-एरर-प्लेस "मिडिल लेवल प्रोसेसिंग" परमेस )
( फेंक ई )
( कैच जावा । लैंग । अपवाद ई
( चलो [ त्रुटि-रेफ ( त्रुटि-नक्शा ? getname ( । getclass e ) )
त्रुटि-रेफ ( यदि ( शून्य ? त्रुटि-रेफ )
( मेक-सिस्टम-एरर-रेफ सिस्टम-टेस्ट एरर-सिस्टम- एरर )
त्रुटि-रेफ )
यानी ( बनाओ-त्रुटि-त्रुटि त्रुटि-जगह "मध्य स्तर प्रसंस्करण" ई परमेस ) ]
( फेंक यानी ) ) ) ))

यह देखा जा सकता है कि परिणामी कोड जावा संस्करण का एक मानकीकृत एनालॉग है। क्लोजर संस्करण का एक अन्य लाभ यह है कि जब मैं त्रुटि से निपटने के तर्क को लागू करता हूं, तो मुझे उन परियोजनाओं के स्रोत कोड को बदलना नहीं पड़ता है जहां इस प्रसंस्करण का उपयोग किया जाता है। यह उचित परियोजना के पुनर्निर्माण के लिए पर्याप्त होगा।

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

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

पुस्तकालय संचालन उदाहरण

स्रोत कोड:

( नीचे दी गई बात [ b ]
( यानी / हैंडलर- यानी / सिस्टम-टेस्ट "निम्न स्तर का ऑपरेशन"
{ "java.lang.ArithmeticException" TestSystemEM $ ErrorRef / BAD_ARGS }
[ बी ]
( दो [ परिणाम ( / a ) )
परिणाम ) ) )

( बीच में अवहेलना [ एक बी ]
( यानी / हैंडलर-यानी यानी / सिस्टम-टेस्ट "मध्य स्तर की प्रोसेसिंग" nil [ a b ]
( दो [ परिणाम ( नीचे एक बी ) ]
परिणाम ) ) )

( बदनाम परीक्षक ] [ बी ]
( let [ c ( + a b ) ]
( यानी / हैंडलर-यानी / सिस्टम-टेस्ट "सार्वजनिक इंटरफ़ेस कार्रवाई" nil [ a b c ]]
( दो [ परिणाम ( मध्य ए बी ) ]
परिणाम ) ) ) )

बिना किसी अपवाद के परिणाम:

उपयोगकर्ता > ( प्रयास करें ( परीक्षक 1 2 )
( इंटरनल एक्ससेप्शन ई को पकड़ें
( Println ( यानी / मानव पठनीय-यानी ई ) ) )

1/2

अपवाद के साथ:

उपयोगकर्ता > ( प्रयास करें ( परीक्षक 1 0 )
( इंटरनल एक्ससेप्शन ई को पकड़ें
( Println ( यानी / मानव पठनीय-यानी ई ) ) )

ErrorRef: BAD_ARGS
समूह पैरामीटर:
className: libs.error.example $ tester
संदेश: सार्वजनिक इंटरफ़ेस कार्रवाई
पैरामीटर:
नाम: a, मान: <int> 1 </ int>
नाम: b, मान: <int> 0 </ int>
नाम: c, मान: <int> 1 </ int>
समूह पैरामीटर:
className: libs.error.example $ मध्य
संदेश: मध्य स्तर प्रसंस्करण
पैरामीटर:
नाम: a, मान: <int> 1 </ int>
नाम: b, मान: <int> 0 </ int>
समूह पैरामीटर:
className: libs.error.example $ निचला भाग
संदेश: निम्न स्तर ऑपरेशन
पैरामीटर:
नाम: b, मान: <int> 0 </ int>
नाम: a, मान: <int> 1 </ int>
नाम: अपवाद, मान: <java.lang.String> त्रुटि संदेश: शून्य से विभाजित करें
java.lang.ArithmeticException: शून्य से विभाजित करें
clojure.lang.Numbers.divide (नंबर.जवा:138) पर
libs.error.example पर $ bottom.invoke (example.clj: 12)
libs.error.example पर $ middle.invoke (example.clj: 17)
libs.error.example पर $ tester.invoke (example.clj: 23)
...
</Java.lang.String>