टीडी, डॉ:
मैं जो पूछ रहा था, उसके बारे में कुछ भ्रम था, इसलिए यहां सवाल के पीछे ड्राइविंग विचार है:
मैंने हमेशा इस सवाल का इरादा रखा कि यह क्या है। मैंने इसे मूल रूप से अच्छी तरह से व्यक्त नहीं किया है। लेकिन इरादे हमेशा " मौड्यूलिक सिंगल-यूनिट, डू-एवरीथिंग इन वन प्लेस, वन फाईल, टाइट कपल " कोड की तुलना में अपनी प्रकृति से मॉड्यूलर, अलग, ढीले कपल, डिकूप्ड, रिफलेक्टेड कोड "होते हैं । बाकी केवल विवरण और इस की विभिन्न अभिव्यक्तियाँ हैं जो मैं तब या अब या बाद में आया था। यह कुछ पैमाने पर सुनिश्चित करने के लिए धीमा है। एक गैर-डीफ़्रेग्ड डिस्क की तरह, आपको हर जगह से टुकड़ों को उठाना होगा। यह धीमा है। पक्का। लेकिन क्या मुझे परवाह करनी चाहिए?
और सवाल यह नहीं है ...
माइक्रो-ऑप्टिमाइज़ेशन, प्रीमेच्योर ऑप्टिमाइज़ेशन इत्यादि के बारे में नहीं। यह "इस या उस हिस्से को मौत के लिए ऑप्टिमाइज़ करने" के बारे में नहीं है।
तो यह क्या है?
यह समग्र कार्यप्रणाली और तकनीकों और लेखन कोड के बारे में सोचने के तरीकों के बारे में है जो समय के साथ उभरा है:
- "इस कोड को एक निर्भरता के रूप में अपनी कक्षा में इंजेक्ट करें"
- "प्रति वर्ग एक फ़ाइल लिखें"
- "अपने डेटाबेस, नियंत्रक, डोमेन से अपना दृष्टिकोण अलग करें"।
- स्पेगेटी समरूप एकल कोडब्लॉक न लिखें, बल्कि कई अलग-अलग मॉड्यूलर घटक लिखें जो एक साथ काम करते हैं
यह इस दशक के भीतर - वर्तमान में - कोड की शैली और शैली के बारे में है, जिसे अधिकांश रूपरेखाओं में देखा गया और इसकी वकालत की गई, सम्मेलनों में वकालत की गई, समुदाय के माध्यम से पारित की गई। यह 'अखंड ब्लॉक' से 'माइक्रोसर्विस' तक की सोच में बदलाव है। और इसके साथ ही मशीन-स्तरीय प्रदर्शन और ओवरहेड, और कुछ प्रोग्रामर-स्तरीय ओवरहेड के रूप में भी मूल्य आता है।
मूल प्रश्न इस प्रकार है:
कंप्यूटर विज्ञान के क्षेत्र में, मैंने यह सोचकर एक उल्लेखनीय बदलाव पर ध्यान दिया है जब यह प्रोग्रामिंग की बात आती है। मैं बहुत बार इस तरह की सलाह पर आता हूं:
- छोटे फ़ंक्शन-वार कोड (अधिक परीक्षण योग्य और इस तरह बनाए रखने योग्य) लिखें
- जब तक आपके अधिकांश तरीके / कार्य केवल कुछ पंक्तियाँ नहीं हैं, तब तक कोड के छोटे और छोटे खंडों में रिफ्लेक्टर विद्यमान होता है और यह स्पष्ट होता है कि उनका उद्देश्य क्या है (जो एक बड़े अखंड ब्लॉक की तुलना में अधिक कार्य करता है)
- फ़ंक्शंस लिखें जो केवल एक काम करते हैं - चिंताओं को अलग करना, आदि (जो आमतौर पर एक स्टैक पर अधिक फ़ंक्शन और अधिक फ़्रेम बनाता है)
- अधिक फ़ाइलें बनाएँ (एक वर्ग प्रति फ़ाइल, अपघटन उद्देश्यों के लिए अधिक कक्षाएं, परत उद्देश्यों के लिए जैसे MVC, डोमेन आर्किटेक्चर, डिज़ाइन पैटर्न, OO, आदि, जो अधिक फ़ाइल सिस्टम कॉल बनाता है)
यह "पुरानी" या "आउटडेटेड" या "स्पेगेटी" कोडिंग प्रथाओं की तुलना में एक बदलाव है जहां आपके पास 2500 लाइनें फैले हुए तरीके हैं, और बड़े वर्ग और देव वस्तुएं सब कुछ कर रही हैं।
मेरा सवाल यह है:
जब यह कॉल मशीन कोड के लिए 1s और 0s तक, विधानसभा निर्देशों के लिए, HDD प्लेटर्स के लिए आती है, तो क्या मुझे इस बात से चिंतित होना चाहिए कि मेरे छोटे-से-छोटे कार्यों और तरीकों की विविधता के साथ मेरा पूरी तरह से अलग-अलग OO कोड अलग है? बहुत अतिरिक्त उपरि?
विवरण
हालांकि मैं इस बात से परिचित नहीं हूं कि OO कोड और इसकी विधि कॉल अंत में ASM में कैसे नियंत्रित की जाती हैं, और कैसे DB कॉल और कंपाइलर कॉल HDD थाली पर चलती एक्ट्यूएटर आर्म में अनुवाद करते हैं, मुझे कुछ पता नहीं है। मैं मानता हूं कि प्रत्येक अतिरिक्त फ़ंक्शन कॉल, ऑब्जेक्ट कॉल, या "#include" कॉल (कुछ भाषाओं में), निर्देशों का एक अतिरिक्त सेट उत्पन्न करता है, जिससे कोड की मात्रा बढ़ रही है और विभिन्न "कोड वायरिंग" ओवरहेड्स को जोड़कर, वास्तविक "उपयोगी" कोड जोड़े बिना। । मैं यह भी कल्पना करता हूं कि हार्डवेयर पर वास्तव में चलने से पहले एएसएम के लिए अच्छे अनुकूलन किए जा सकते हैं, लेकिन यह अनुकूलन केवल इतना ही कर सकता है।
इसलिए, मेरा सवाल - कितना ओवरहेड (अंतरिक्ष और गति में) अच्छी तरह से अलग कोड (कोड जो सैकड़ों फाइलों, कक्षाओं और डिजाइन पैटर्न, आदि में विभाजित है) करता है, वास्तव में "एक बड़ी विधि" होने की तुलना में परिचय देता है सब कुछ एक अखंड फ़ाइल में ", इस ओवरहेड के कारण?
स्पष्टता के लिए अद्यतन करें:
मैं मान रहा हूं कि समान कोड लेने और इसे विभाजित करने, इसे फिर से भरने, इसे अधिक से अधिक कार्यों और वस्तुओं और विधियों में डिकॉप करने के परिणामस्वरूप छोटे कोड टुकड़ों के बीच अधिक से अधिक पैरामीटर का परिणाम होगा । क्योंकि सुनिश्चित करने के लिए, रिफैक्टिंग कोड को थ्रेड को चालू रखना होता है, और इसके लिए पैरामीटर पासिंग की आवश्यकता होती है। अधिक विधियाँ या अधिक कक्षाएं या अधिक फैक्ट्री विधियाँ डिज़ाइन के पैटर्न, परिणाम के अधिक ओवरहेड के परिणाम के बारे में जानकारी के विभिन्न बिट्स से अधिक एकल अखंड वर्ग या विधि में है।
यह कहीं कहा गया था (टीबीडी) कि सभी कोड का 70% तक एएसएम के एमओवी निर्देश से बना है - उचित चर के साथ सीपीयू रजिस्टर लोड हो रहा है, वास्तविक गणना नहीं की जा रही है। मेरे मामले में, आप CPU और PUSH / POP निर्देशों के साथ कोड और विभिन्न कोड के बीच गुजरने वाले पैरामीटर प्रदान करने के लिए लोड करते हैं। छोटे आप अपने कोड के टुकड़े बनाते हैं, अधिक उपरि "लिंकेज" की आवश्यकता होती है। मुझे चिंता है कि यह लिंकेज सॉफ्टवेयर ब्लोट और स्लो-डाउन में जुड़ जाता है और मैं सोच रहा हूं कि क्या मुझे इस बारे में चिंतित होना चाहिए, और कितना, यदि कोई हो, तो वर्तमान और भावी पीढ़ी के प्रोग्रामर जो अगली शताब्दी के लिए सॉफ्टवेयर का निर्माण कर रहे हैं। , इन प्रथाओं का उपयोग करके निर्मित सॉफ्टवेयर के साथ रहना और उपभोग करना होगा।
अद्यतन: एकाधिक फ़ाइलें
मैं अब नया कोड लिख रहा हूं जो धीरे-धीरे पुराने कोड की जगह ले रहा है। विशेष रूप से मैंने नोट किया है कि पुरानी कक्षाओं में से एक ~ 3000 लाइन फाइल थी (जैसा कि पहले उल्लेख किया गया है)। अब यह विभिन्न निर्देशिकाओं में स्थित 15-20 फाइलों का एक समूह बनता जा रहा है, जिनमें परीक्षण फाइलें शामिल हैं और PHP फ्रेमवर्क शामिल नहीं है जो मैं कुछ चीजों को एक साथ बांधने के लिए उपयोग कर रहा हूं। और भी फाइलें आ रही हैं। जब डिस्क I / O की बात आती है, तो एक बड़ी फ़ाइल लोड करने की तुलना में कई फ़ाइलों को लोड करना धीमा होता है। बेशक सभी फाइलें लोड नहीं होती हैं, उन्हें आवश्यकतानुसार लोड किया जाता है, और डिस्क कैशिंग और मेमोरी कैशिंग विकल्प मौजूद होते हैं, और फिर भी मेरा मानना है कि स्मृति की loading multiple filesतुलना loading a single fileमें अधिक प्रसंस्करण होता है। मैं इसे अपनी चिंता में शामिल कर रहा हूं।
अद्यतन: निर्भरता सब कुछ इंजेक्ट करें
थोड़ी देर बाद इस पर वापस आ रहा हूं .. मुझे लगता है कि मेरा सवाल गलत था। या शायद मैंने कुछ जवाबों को गलत समझा। मैं माइक्रो-ऑप्टिमाइज़िंग के बारे में बात नहीं कर रहा हूं, क्योंकि कुछ जवाब एकल हो गए हैं, (कम से कम मुझे लगता है कि मैं जो कॉल कर रहा हूं वह माइक्रो-ऑप्टिमाइज़ेशन के बारे में बात कर रहा है) एक मिथ्या नाम है लेकिन "रिफ्लेक्टर कोड को तंग युग्मन ढीला करने के लिए" के आंदोलन के बारे में। कोड के हर स्तर पर। मैं अभी हाल ही में Zend Con से आया था, जहां इस शैली की संहिता सम्मेलन के मुख्य बिंदुओं और केंद्र बिंदुओं में से एक रही है। व्यू से तार्किक तर्क, मॉडल से दृश्य, डेटाबेस से मॉडल, और यदि आप कर सकते हैं, तो डेटाबेस से डेटा को कम कर दें। निर्भरता-सब कुछ इंजेक्ट करें, जिसका अर्थ कभी-कभी केवल वायरिंग कोड (फ़ंक्शन, कक्षाएं, बॉयलरप्लेट) जोड़ना होता है जो कुछ भी नहीं करता है, लेकिन ज्यादातर मामलों में आसानी से कोड आकार को दोगुना करने के लिए एक सीवन / हुक बिंदु के रूप में कार्य करता है।
अद्यतन 2: "अधिक फ़ाइलों में कोड को अलग करता है" प्रदर्शन को काफी प्रभावित करता है (कंप्यूटिंग के सभी स्तरों पर)
compartmentalize your code into multiple filesआज के कंप्यूटिंग (प्रदर्शन, डिस्क उपयोग, मेमोरी प्रबंधन, सीपीयू प्रसंस्करण कार्यों) के प्रभाव का दर्शन कैसे होता है ?
मैं इस बारे में बात कर रहा हूँ
इससे पहले कि ...
काल्पनिक रूप से अभी तक काफी वास्तविक नहीं है, इसलिए आप अतीत में एक फाइल के एक मोनो-ब्लॉक को आसानी से लिख सकते हैं, जिसमें मॉडल और व्यू और कंट्रोलर स्पेगेटी या स्पैगेटी-कोडेड नहीं है, लेकिन यह सब कुछ एक बार पहले ही लोड हो जाने पर चलता है। C कोड का उपयोग करते हुए अतीत में कुछ बेंचमार्क करने से मुझे पता चला कि यह एक 900Mb फाइल को मेमोरी में लोड करने और इसे बड़ी मात्रा में प्रोसेस करने की तुलना में बहुत छोटा फाइलों के एक समूह को लोड करने और एक छोटे से शांति-भोजन में प्रोसेस करने के लिए यह बहुत तेज़ है। अंत में एक ही काम कर रहे विखंडू।
.. और अब*
आज मैं अपने आप को एक ऐसे कोड को देखता हूं, जो एक लेज़र दिखाता है, जिसमें विशेषताएं हैं .. यदि कोई आइटम "ऑर्डर" है, तो HTML ऑर्डर दिखाएं। यदि एक पंक्ति वस्तु को कॉपी किया जा सकता है, तो एचटीएमएल ब्लॉक को प्रिंट करें जो एक आइकन प्रदर्शित करता है और एचटीएमएल पैरामीटर इसके पीछे आपको प्रतिलिपि बनाने की अनुमति देता है। यदि आइटम को ऊपर या नीचे ले जाया जा सकता है, तो उपयुक्त HTML तीर प्रदर्शित करें। आदि मैं Zend फ्रेमवर्क के माध्यम से कर सकते हैंpartial()कॉल, जिसका अनिवार्य रूप से अर्थ है "एक फ़ंक्शन को कॉल करें जो आपके मापदंडों को लेता है और उन्हें एक अलग HTML फ़ाइल में सम्मिलित करता है जिसे वह कॉल भी करता है"। इस बात पर निर्भर करता है कि मैं कितना विस्तृत होना चाहता हूं, मैं बही के सबसे छोटे हिस्सों के लिए अलग-अलग HTML फ़ंक्शन बना सकता हूं। तीर के लिए एक, नीचे तीर, "मैं इस आइटम को कॉपी कर सकता हूं" के लिए एक, आदि वेबपेज के एक छोटे से हिस्से को प्रदर्शित करने के लिए आसानी से कई फाइलें बना रहा है। मेरे कोड और दृश्यों के पीछे Zend फ्रेमवर्क कोड लेते हुए, सिस्टम / स्टैक शायद 20-30 अलग-अलग फ़ाइलों के करीब कॉल करता है।
क्या?
मुझे पहलुओं पर दिलचस्पी है, मशीन पर पहनने और आंसू जो कई छोटे अलग-अलग फाइलों में कोड कंपार्टमेंटिंग करके बनाए जाते हैं।
उदाहरण के लिए, अधिक फ़ाइलों को लोड करने का अर्थ है उन्हें फ़ाइल सिस्टम के विभिन्न स्थानों में स्थित होना और भौतिक HDD के विभिन्न स्थानों में, जिसका अर्थ है कि अधिक HDD की तलाश और समय पढ़ना।
सीपीयू के लिए इसका अर्थ शायद विभिन्न रजिस्टरों को स्विच और लोड करना अधिक संदर्भ है।
इस उप-ब्लॉक में (# 2 अपडेट करें) मैं अधिक सख्ती से दिलचस्पी रखता हूं कि एक ही फाइल में एक ही कार्य को करने के लिए कई फाइलों का उपयोग कैसे किया जाए, जो सिस्टम प्रदर्शन को प्रभावित करता है।
सरल HTML बनाम Zend Form API का उपयोग करना
मैंने नवीनतम और महानतम आधुनिक OO प्रथाओं के साथ Zend Form API का उपयोग किया, ताकि POSTडोमेन ऑब्जेक्ट्स में रूपांतरण के साथ HTML फॉर्म का निर्माण किया जा सके।
इसे बनाने में मुझे 35 फाइलें लगीं।
35 files =
= 10 fieldsets x {programmatic fieldset + fieldset manager + view template}
+ a few supporting files
जिनमें से सभी को कुछ सरल एचटीएमएल + पीएचपी + जेएस + सीएसएस फाइलों के साथ बदला जा सकता है, शायद कुल 4 लाइट-वेट फाइलें।
क्या यह बेहतर है? क्या यह इसके योग्य है? ... 35 फाइलों को लोड करने की कल्पना करें + कई Zend Zramework पुस्तकालय फाइलें जो उन्हें काम करती हैं, बनाम 4 सरल फाइलें।