फ्लॉप सही दिशा में नेतृत्व कर रहा है। "एकल जिम्मेदारी सिद्धांत" मूल रूप से प्रक्रियाओं पर लागू होता है। उदाहरण के लिए, डेनिस रिची कहेंगे कि एक फ़ंक्शन को एक काम करना चाहिए और इसे अच्छी तरह से करना चाहिए। फिर, C ++ में, ब्रेज़ेन स्ट्रॉस्ट्रुप कहेंगे कि एक वर्ग को एक काम करना चाहिए और इसे अच्छी तरह से करना चाहिए।
ध्यान दें कि, अंगूठे के नियमों को छोड़कर, इन दोनों का औपचारिक रूप से एक-दूसरे के साथ बहुत कम या कोई लेना-देना नहीं है। वे केवल उसी को पूरा करते हैं जो प्रोग्रामिंग भाषा में व्यक्त करने के लिए सुविधाजनक है। खैर, यह कुछ है। लेकिन यह काफी अलग कहानी है कि फ्लॉप क्या चल रहा है।
आधुनिक (यानी, फुर्तीली और DDD) कार्यान्वयन इस बात पर अधिक ध्यान केंद्रित करते हैं कि प्रोग्रामिंग भाषा क्या व्यक्त कर सकती है, उससे अधिक महत्वपूर्ण व्यवसाय के लिए क्या है। आश्चर्य की बात यह है कि प्रोग्रामिंग भाषाओं ने अभी तक पकड़ नहीं बनाई है। पुरानी फोरट्रान जैसी भाषाएं उन जिम्मेदारियों को पकड़ लेती हैं जो उस समय के प्रमुख वैचारिक मॉडल में फिट होती हैं: प्रक्रियाएं प्रत्येक कार्ड पर लागू होती हैं क्योंकि यह कार्ड रीडर, या (सी के रूप में) प्रसंस्करण के साथ चली गई जो प्रत्येक रुकावट के साथ हुई। इसके बाद एडीटी भाषाएं आईं, जो इस बात पर कब्जा करने के लिए परिपक्व हो गईं कि डीडीडी लोग बाद में महत्वपूर्ण होने के रूप में फिर से आविष्कार करेंगे (हालांकि जिम नेबर्स ने इस सबसे पता लगाया था, प्रकाशित किया गया था, और 1968 तक उपयोग में था): जिसे आज हम कक्षाएं कहते हैं । (वे मॉड्यूल नहीं हैं।)
यह कदम एक पेंडुलम स्विंग की तुलना में कम विकसित था। जैसा कि पेंडुलम डेटा में आया था, हम फोरट्रान में निहित उपयोग के मामले को खो चुके थे। जब आपका प्राथमिक फोकस स्क्रीन पर डेटा या आकृतियों को शामिल करता है तो ठीक है। यह पॉवरपॉइंट जैसे कार्यक्रमों के लिए एक शानदार मॉडल है, या कम से कम इसके सरल संचालन के लिए।
जो मिला वह सिस्टम की जिम्मेदारियां हैं । हम DDD के तत्व नहीं बेचते हैं। और हम कक्षा के तरीकों को अच्छी तरह से नहीं समझते हैं। हम सिस्टम की जिम्मेदारियां बेचते हैं। कुछ स्तर पर, आपको अपने सिस्टम को एकल जिम्मेदारी सिद्धांत के आसपास डिजाइन करने की आवश्यकता है।
इसलिए यदि आप रेबेका विर्फ़्स-ब्रॉक, या मेरे जैसे लोगों को देखते हैं, जो क्लास के तरीकों के बारे में बात करते थे, तो अब हम उपयोग के मामलों के बारे में बात कर रहे हैं। यही हम बेचते हैं। वे सिस्टम ऑपरेशन हैं। एक उपयोग के मामले में एक ही जिम्मेदारी होनी चाहिए। एक उपयोग मामला शायद ही कभी एक वास्तुशिल्प इकाई है। लेकिन हर कोई यह दिखावा करने की कोशिश कर रहा था। उदाहरण के लिए एसओए लोगों को गवाह करें।
यही कारण है कि मैं Trygve Reenskaug के DCI आर्किटेक्चर के बारे में उत्साहित हूं - जो कि लीन आर्किटेक्चर पुस्तक में वर्णित है। यह अंततः कुछ वास्तविक कद देता है जो "एकल जिम्मेदारी" के लिए एक मनमाना और रहस्यमय पालन करता था - जैसा कि ऊपर दिए गए अधिकांश तर्क में पाया गया है। वह कद मानव मानसिक मॉडल से संबंधित है: अंतिम उपयोगकर्ता पहले और प्रोग्रामर दूसरे। यह व्यापारिक चिंताओं से संबंधित है। और, लगभग घटित होने से, यह परिवर्तन को चुनौती देता है क्योंकि फ्लॉप हमें चुनौती देता है।
एकल-जिम्मेदारी सिद्धांत, जैसा कि हम जानते हैं कि यह या तो एक डायनासोर है जो अपने दिनों के मूल से बचा हुआ है या एक शौक घोड़ा है जिसे हम समझने के विकल्प के रूप में उपयोग करते हैं। आपको महान सॉफ्टवेयर करने के लिए इनमें से कुछ शौक घोड़ों को पीछे छोड़ने की जरूरत है। और इसके लिए बॉक्स से हटकर सोचने की जरूरत है। चीजों को सरल और आसान समझना तभी काम करता है जब समस्या सरल और समझने में आसान हो। मुझे उन समाधानों में बहुत दिलचस्पी नहीं है: वे विशिष्ट नहीं हैं, और यह वह जगह नहीं है जहां चुनौती निहित है।
