कैसे कोई सार्थक रूप से रखरखाव को मापता है?


23

संदर्भ: मैं एक अखिल एमएस दुकान में एक उद्यम डेवलपर हूं।

किसी को भी कोड या एक आवेदन के उद्देश्य को बनाए रखने के उद्देश्य से मापने का एक अच्छा तरीका सुझा सकते हैं ?

क्यों बनाए रखा जाता है : मैं अपने समूह में केवल "गुणवत्ता" मीट्रिक से थक गया हूं, केवल बग की संख्या और कोड कवरेज के आसपास घूम रहा हूं। दोनों मेट्रिक्स खेल के लिए आसान हैं, खासकर जब आप रखरखाव को माप नहीं रहे हैं। शिथिलता और समयसीमा के परिणामस्वरूप भारी मात्रा में तकनीकी ऋण प्राप्त होता है जो कभी भी संबोधित नहीं होता है।

उद्देश्यपूर्ण रूप से मापने की क्षमता क्यों : मैं एक बड़े उद्यम समूह में काम करता हूं। यदि आप इसे उद्देश्यपूर्ण तरीके से नहीं माप सकते हैं, तो आप लोगों को इसके लिए जवाबदेह नहीं ठहरा सकते हैं या उन्हें इससे बेहतर नहीं बना सकते हैं। विशेषण माप या तो नहीं होते हैं या लगातार नहीं होते हैं।

मैं VS2010 कोड मेट्रिक्स देख रहा हूं , लेकिन मैं सोच रहा हूं कि क्या किसी और की सिफारिशें हैं।


@ मैं - मैं सहमत हूं, लेकिन कम से कम यह मुझे शुरुआत करने के लिए जगह देगा। अभी तो कुछ भी नहीं है; इसका नाम भी नहीं है।
मुलवल्कर

1
मैं वास्तव में यह नहीं देखता कि आप बिना सहकर्मी की समीक्षा के यह कैसे कर सकते हैं। किसी को कोड की एक इकाई को देखने और जाने के लिए वास्तव में समग्र प्रणाली के डिजाइन (और एक मौजूद होना चाहिए) को समझने की जरूरत है ... hm इसे एक बेहतर डिजाइन द्वारा सुधार किया जा सकता है या यह कोड पश्चाताप है या अच्छा प्रभु आपके उपकरण पुराने हैं ... इसी तरह के एक नोट पर, आप इस तरह के दिशानिर्देशों का पालन कर सकते हैं, "हे लोग इसके ग्रिड ग्रिड में अनुक्रमित करने के लिए एक अच्छा विचार नहीं है, आइटमटैंप का उपयोग करें और इसके बजाय नाम से कॉलम चुनें"। जब यह इसके नीचे आता है, तो देवता सिर्फ अच्छे और टीम के अनुकूल होते हैं। दा विंची अजीब नहीं सिखा सकते हैं।
पी। ब्रायन। मैके

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

3
"जो कुछ भी गिना जा सकता है वह जरूरी नहीं गिनता है; जो कुछ भी मायने रखता है उसे जरूरी नहीं गिना जा सकता।" -इंस्टीन
जेसन बेकर

@nlawalker उन समस्याओं के अतिरिक्त जो उत्तरदाताओं ने पहले ही उठाई थीं, आपका प्रश्न एक प्रश्नात्मक धारणा से भरा हुआ है, कि यदि इस तरह के माप में मौजूद लोग इसके बारे में कुछ कर सकते हैं। कम मेनटेनेंस सॉफ्टवेयर के लिए बाहरी विभिन्न कारकों का परिणाम है: कितनी मुश्किल या अच्छी तरह से परिभाषित की गई समस्या है कार्यक्रम को हल करने का प्रयास, कर्मचारियों का अनुभव, कारोबार, बाजार की आवश्यकताओं के लिए समय, गुंजाइश में बदलाव ... आप बस एक इनाम नहीं डाल सकते हैं इस उम्मीद पर समस्या अच्छी इच्छा का विषय है।
आर्थर हैवेलिस

जवाबों:


7

स्थिरता को मापने के साथ चेतावनी यह है कि आप भविष्य की भविष्यवाणी करने का प्रयास कर रहे हैं। कोड कवरेज, बग काउंट, एलओसी, साइक्लोमैटिक जटिलता सभी वर्तमान से निपटते हैं

वास्तविकता यह है कि जब तक आपके पास ठोस सबूत नहीं है कि कोड के रूप में बनाए रखने योग्य नहीं है..हे ... बग को ठीक करने से गैर-बनाए रखने वाले कोड के कारण गैर-आवश्यक समय के घंटे की मात्रा का कारण बनता है; तब पैर पर खड़ा होना स्वाभाविक रूप से कठिन होगा। इस उदाहरण में यह इस तथ्य के कारण हो सकता है कि एक अत्यधिक जटिल कार्यप्रणाली का उपयोग किया गया था जब कुछ बहुत सरल हो जाएगा। एक ऐसे क्षेत्र में फैलना जहाँ आप कार्यप्रणाली, प्रतिमानों और सर्वोत्तम प्रथाओं को मापने का प्रयास करते हैं, थोड़े से दीर्घकालिक लाभ के साथ यह कठिन होता जा रहा है।

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


7

ठीक है, मैं जिस उपाय का उपयोग करता हूं, या यह सोचना पसंद करता हूं कि मैं उपयोग करता हूं, क्या यह है:

प्रत्येक स्वतंत्र, एकल, एक-पंक्ति, टेक-इट-लीव-इट-फंक्शनल आवश्यकता के लिए, इसे लागू करने से पहले कोड बेस को स्नैपशॉट दें। फिर इसे लागू करें, प्रक्रिया में पेश किए गए किसी भी कीड़े को खोजने और ठीक करने सहित। फिर diffसे पहले और बाद में कोड बेस के बीच चलाएं । diffआप सभी सम्मिलन, हटाने और संशोधनों कि परिवर्तन लागू की एक सूची दिखाई देगा। (कोड की 10 लगातार पंक्तियाँ सम्मिलित करना एक परिवर्तन है।) कितने परिवर्तन हुए? वह संख्या जितनी छोटी होती है, आमतौर पर, कोड उतना ही अधिक बनाए रखने योग्य होता है।

मैं स्रोत कोड के अतिरेक को कहता हूं , क्योंकि यह त्रुटि-सुधार कोड की अतिरेक की तरह है। जानकारी 1 चंक में निहित थी, लेकिन एन चंक्स के रूप में एन्कोड किया गया था, जिसे सभी को एक साथ किया जाना है, सुसंगत होना।

मुझे लगता है कि यह DRY के पीछे का विचार है, लेकिन यह थोड़ा अधिक सामान्य है। इसका कारण यह है कि गिनती कम होना अच्छा है, अगर यह एक विशिष्ट आवश्यकता को लागू करने के लिए एन में परिवर्तन करता है, और एक निंदनीय प्रोग्रामर के रूप में आपको केवल एन -1 या एन -2 मिलता है, जो पहले सही ढंग से किया गया है, तो आपने इसमें डाल दिया है। 1 या 2 कीड़े। O (N) प्रोग्रामिंग प्रयास के शीर्ष पर, उन बग्स की खोज, स्थित और मरम्मत की जानी है। इसलिए छोटा एन अच्छा है।

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

मुझे लगता है कि जब एन काफी दूर हो जाता है (इष्टतम 1 है) स्रोत कोड एक डोमेन-विशिष्ट-भाषा (डीएसएल) की तरह अधिक पढ़ता है। यह कार्यक्रम समस्या को इतना "हल" नहीं करता है क्योंकि यह समस्या को "बताता है", क्योंकि आदर्श रूप से प्रत्येक आवश्यकता को कोड के एक ही टुकड़े के रूप में पुनर्स्थापित किया जाता है।

दुर्भाग्य से, मैं लोगों को यह नहीं सीखा कि यह कैसे करना है। बल्कि उन्हें लगता है कि मानसिक संज्ञाएं कक्षाएं बन जानी चाहिए, और क्रियाएं विधियां बन जाती हैं, और वे जो कुछ भी करते हैं वह क्रैंक है। मेरे अनुभव में 30 या उससे अधिक एन के साथ कोड में परिणाम है।


क्या यह बहुत भव्य धारणा नहीं है - कि सभी कार्यात्मक आवश्यकताएं लगभग एक ही आकार की हैं? और क्या यह मीट्रिक जिम्मेदारियों के अलगाव को हतोत्साहित नहीं करेगा? मुझे एक क्षैतिज सुविधा को लागू करने की आवश्यकता है; इसलिए सबसे अधिक "बनाए रखने योग्य" कोड एक प्रोग्राम का एक निकट-कुल पुनर्लेखन है जो पूरी तरह से एक अखंड पद्धति के भीतर निहित है।
आरोन

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

5

स्थिरता नहीं है कि औसत दर्जे का वास्तव में। यह अपने अनुभवों और प्राथमिकताओं के आधार पर किसी व्यक्ति का व्यक्तिपरक दृष्टिकोण है।

कोड के एक टुकड़े के लिए एक आदर्श डिजाइन के विचार के साथ आते हैं ।

फिर उस सही से वास्तविक कोड के किसी भी विचलन के लिए कुछ संख्या से 100 के मूल्य में कमी आती है। क्या वास्तव में एक चुने हुए गैर-सही दृष्टिकोण के परिणामों पर निर्भर करता है।

एक उदाहरण:

कोड का एक टुकड़ा कुछ डेटा प्रारूप को पढ़ता है और आयात करता है और कुछ गलत होने पर त्रुटि संदेश दिखा सकता है।

एक सही समाधान (100) में एक सामान्य स्थान पर रखे गए त्रुटि संदेश होंगे। यदि आपके समाधान में उन्हें कोड में सीधे स्ट्रिंग स्थिरांक के रूप में हार्ड-कोडित किया गया है, तो आप कहते हैं, 15 बंद। तो आपका मेंटेनेंस इंडेक्स 85 हो जाता है।


4

कोड का एक परिणाम जो बनाए रखना मुश्किल है, वह यह है कि बग को ठीक करने के लिए आपको अधिक समय ("औसत") पर ले जाना होगा। इसलिए, पहली नज़र में एक मीट्रिक को बग को ठीक करने में लगने वाला समय प्रतीत होगा जब इसे सौंपा गया है (यानी फिक्स शुरू हो गया है) जब यह "परीक्षण के लिए तैयार" है।

"औसत" (क्या कभी इसका मतलब है) समय प्राप्त करने के लिए उचित संख्या में कीड़े तय करने के बाद, यह केवल वास्तव में काम करेगा। आप किसी विशेष बग के लिए आकृति का उपयोग नहीं कर सकते हैं क्योंकि नीचे ट्रैक करना कितना कठिन है, यह कोड की "स्थिरता" पर निर्भर नहीं है।

बेशक, जब आप अधिक बग्स को ठीक करते हैं तो कोड बनाए रखना "आसान" हो जाता है क्योंकि आप इसे बेहतर बना रहे हैं (या कम से कम आपको होना चाहिए) और आप कोड से अधिक परिचित हो रहे हैं। काउंटरिंग यह तथ्य यह है कि बग अधिक अस्पष्ट होने के लिए प्रवृत्त होंगे और इसलिए नीचे ट्रैक करना भी कठिन होगा।

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


2

मुझे लगता है कि विज़ुअल स्टूडियो कोड मेट्रिक्स एक त्वरित "स्थिरता" मीट्रिक प्रदान करने के लिए काफी सभ्य है। 5 प्राथमिक मैट्रिक्स कैप्चर किए गए हैं:

  • साइक्लोमेटिक कम्पलेक्सिटी
  • वंशानुक्रम की गहराई
  • क्लास कपलिंग
  • कोड की लाइनें (प्रति विधि, प्रति वर्ग, प्रति परियोजना, जो भी, आपके स्तर पर रोल-अप के आधार पर)

मेंटेनेंस इंडेक्स वह है जो मुझे लगता है। यह एक समग्र सूचकांक है, जिसके आधार पर:

  1. कुल आकार (कोड की पंक्तियाँ)
  2. # कक्षाओं या फ़ाइलों का
  3. # तरीके के
  4. 20 से ऊपर साइक्लोमैटिक जटिलता (या 10 - विन्यासनीय, 10 मेरी प्राथमिकता है)
  5. प्रतिलिपि

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

गणना पर अधिक जानकारी के लिए श्वेत पत्र देखें ।


1

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

साइक्लोमैटिक जटिलता एक माप है कि कोड में कितने पथ हैं। प्रत्येक पथ का परीक्षण किया जाना चाहिए (लेकिन शायद नहीं है)। लगभग 20 से ऊपर की जटिलता के साथ कुछ को छोटे मॉड्यूल में तोड़ दिया जाना चाहिए। 20 की एक साइबर जटिलता के साथ एक मॉड्यूल (20 क्रमिक if then elseब्लॉकों के साथ एक यह नकल कर सकता है ) के परीक्षण के लिए 2 ^ 20 पथ की ऊपरी सीमा होगी।

क्लास कपलिंग इस बात का एक पैमाना है कि कक्षाएं कितनी कड़ी हैं। कुछ बुरे कोड का एक उदाहरण जो मैंने अपने पिछले नियोक्ता के साथ काम किया था, उसमें कंस्ट्रक्टर में लगभग 30 वस्तुओं के साथ एक "डेटा लेयर" घटक शामिल है। उस घटक के लिए ज्यादातर "ज़िम्मेदार" व्यक्ति व्यवसायी और यूआई लेयर मापदंडों को कंस्ट्रक्टर / खुली कॉलों में जोड़ता रहा, जब तक कि यह कीचड़ की एक बड़ी गेंद नहीं थी। यदि मेमोरी मुझे सही ढंग से सेवा देती है, तो लगभग 15 अलग-अलग नए / खुले कॉल थे (कुछ अब नहीं इस्तेमाल किए जाते हैं), सभी थोड़ा अलग सेट के मापदंडों के साथ। हमने उसे इस तरह से अधिक सामान करने से रोकने के एकमात्र उद्देश्य के लिए कोड समीक्षा शुरू की - और यह देखने से बचने के लिए जैसे हम उसे बाहर गा रहे थे, हमने टीम पर सभी के कोड की समीक्षा की, इसलिए हमने 4-6 के लिए लगभग आधा दिन बर्बाद कर दिया। लोग हर दिन, क्योंकि हमने नहीं किया '


2
सभी के लिए कोड की समीक्षा करना एक बुरी बात नहीं है, ईमानदारी से। आपको ऐसा लग सकता है कि आप समय बर्बाद कर रहे हैं, लेकिन जब तक हर कोई इसे सुस्त करने के बहाने के रूप में उपयोग नहीं कर रहा है, तब तक आपको उनके बारे में मूल्यवान जानकारी प्राप्त करनी चाहिए
आनन।

1

नीचे की रेखा पर, रखरखाव वास्तव में केवल आवश्यकता के बाद मापा जा सकता है , इससे पहले नहीं । यही है, आप केवल यह बता सकते हैं कि क्या एक कोड कोड बनाए रखा जा सकता है, जब आपको इसे बनाए रखना होगा।

यह मापना अपेक्षाकृत स्पष्ट है कि बदलती आवश्यकताओं के लिए कोड के एक टुकड़े को अनुकूलित करना कितना आसान था। यह समय से पहले असंभव माप के करीब है, यह आवश्यकताओं में परिवर्तन का जवाब कैसे देगा। इसका मतलब होगा, आपको आवश्यकताओं में बदलाव की भविष्यवाणी करनी होगी। और अगर आप ऐसा कर सकते हैं, तो आपको एक अच्छी कीमत मिलनी चाहिए;)

केवल एक चीज जो आप कर सकते हैं, वह है ठोस नियमों (जैसे कि ठोस सिद्धांतों) के एक सेट पर, अपनी टीम के साथ सहमत होना, कि आप सभी का मानना ​​है कि आम तौर पर स्थिरता में वृद्धि होती है।
यदि सिद्धांतों को अच्छी तरह से चुना गया है (मुझे लगता है कि एसओएलआईडी के साथ जाना एक अच्छा विकल्प होगा) के साथ शुरू करने के लिए, आप काफी स्पष्ट रूप से प्रदर्शित कर सकते हैं कि उनका उल्लंघन किया जा रहा है और लेखकों को इसके लिए जवाबदेह ठहराया जा सकता है।
आपके पास एक बहुत कठिन समय होगा, बनाए रखने के लिए एक निरपेक्ष उपाय को बढ़ावा देने की कोशिश करते हुए, जबकि अपनी टीम को स्थापित सिद्धांतों के एक सहमत सेट पर यथार्थवादी होने के लिए आकस्मिक रूप से आश्वस्त करना।


1

भारी मात्रा में तकनीकी ऋण जो वास्तव में कभी नहीं मिलते हैं

तकनीकी ऋण के बारे में क्या "घटनाओं से आगे निकल गया है"?

मैं गंदे कोड लिखता हूं और इसे उत्पादन में शामिल करता हूं।

आप निरीक्षण करते हैं - सही ढंग से - कि यह बनाए रखने योग्य नहीं है।

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

"तकनीकी ऋण" एक विधायी परिवर्तन से समाप्त हो गया है जो इसे सभी अप्रचलित बनाता है।

बाहरी विचारों के कारण "स्थिरता" मीट्रिक "खराब" से "अप्रासंगिक" हो गई।

इसे कैसे मापा जा सकता है?


"सौ साल में हम सभी मर जाएंगे और इनमें से कोई भी बात नहीं होगी। चीजों को परिप्रेक्ष्य में रखता है, है ना?" अगर कुछ भी अप्रासंगिक है, तो यह प्रतिक्रिया है जो सवाल का जवाब नहीं है।
मार्टिन माट

0

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


0

प्रश्नावली

डेवलपर्स के लिए एक अनाम प्रश्नावली बनाने के बारे में क्या, महीने में एक बार भरने के लिए? सवाल कुछ इस तरह होंगे:

  • पिछले महीने आपका कितना समय प्रोजेक्ट एक्स पर खर्च हुआ है (लगभग) [0% ... 100%]
  • आप स्थिरता के मामले में कोड आधार की स्थिति को कैसे आंकेंगे [वास्तव में गरीब, गरीब, तटस्थ, ठीक, अच्छा, वास्तव में अच्छा]।
  • आप परियोजना की जटिलता की तुलना में कोड आधार को कितना जटिल बना सकते हैं [जिस तरह से बहुत जटिल, ठीक ही सही, बहुत सरल भी]।
  • कोड आधार की अत्यधिक जटिलता के कारण आपने अपने कार्यों को हल करने में कितनी बार आपको महसूस किया? [बिल्कुल नहीं, एक बार थोड़ी देर में, अक्सर, लगातार]।

(उन अतिरिक्त प्रश्नों को जोड़ने के लिए स्वतंत्र महसूस करें, जो आपको लगता है कि टिप्पणियों में स्थिरता बनाए रखने में उपयोगी होंगे और मैं उन्हें जोड़ दूंगा।)


0

मैं स्थिरता को देखने के दो तरीकों के बारे में सोच सकता हूं (मुझे यकीन है कि उम्मीद है कि अन्य अच्छी परिभाषाओं के साथ आ सकते हैं।

बिना समझे संशोधन।

क्या बग फिक्स करने वाला कोड में आ सकता है और यह समझने की आवश्यकता के बिना किसी समस्या को ठीक कर सकता है कि पूरा सिस्टम कैसे काम करता है।

यह व्यापक इकाई परीक्षण (प्रतिगमन परीक्षण) प्रदान करके प्राप्त किया जा सकता है। आपको यह जांचने में सक्षम होना चाहिए कि सिस्टम में कोई भी परिवर्तन नहीं बदलता है कि सिस्टम किसी विशिष्ट अच्छे इनपुट के साथ कैसे व्यवहार करता है।

इस स्थिति में एक बग फिक्सर को सिस्टम के केवल न्यूनतम ज्ञान के साथ (सरल) बग में आने और ठीक करने में सक्षम होना चाहिए। यदि फिक्स काम करता है, तो प्रतिगमन परीक्षणों में से कोई भी विफल नहीं होना चाहिए। यदि कोई प्रतिगमन परीक्षण विफल हो जाता है तो आपको चरण 2 में जाने की आवश्यकता है।

maintainabilty1 = K1 . (Code Coverage)/(Coupling of Code) * (Complexity of API)

समझ के साथ संशोधन।

यदि बग फिक्स गैर तुच्छ हो जाता है और आपको सिस्टम को समझने की आवश्यकता है। फिर जैसे सिस्टम का डॉक्यूमेंटेशन क्या होता है। हम बाहरी एपीआई के प्रलेखन पर बात नहीं कर रहे हैं (वे अपेक्षाकृत बेकार हैं)। हमें यह समझने की आवश्यकता है कि सिस्टम कैसे काम करता है जहां कार्यान्वयन में उपयोग किए जाने वाले किसी भी चतुर (हैक हैक) चालें आदि।

लेकिन प्रलेखन पर्याप्त नहीं है कोड को स्पष्ट और समझने योग्य होने की आवश्यकता है। एक कोड की समझ को मापने के लिए हम थोड़ी सी चाल का उपयोग कर सकते हैं। डेवलपर द्वारा कोडिंग समाप्त करने के बाद, उसे किसी और चीज़ पर काम करने के लिए एक महीना दें। फिर उन्हें वापस आने के लिए कहें और सिस्टम को इस हद तक दस्तावेज़ दें कि एक घाट अब सिस्टम को समझ सके। यदि कोड को समझना आसान है, तो यह त्वरित होना चाहिए। अगर यह बुरी तरह से लिखा गया है, तो वे वर्कआउट करने और दस्तावेज़ लिखने में अधिक समय लेंगे।

तो शायद हम इसका कुछ उपाय कर सकते हैं:

maintainability2 = K2 . (Size of doc)/(Time to write doc)

0

मुझे अक्सर लगता है कि "सबसे छोटा समतुल्य" समाधान सबसे अधिक रखरखाव योग्य है।

यहाँ सबसे छोटी का अर्थ है सबसे छोटा ऑपरेशन (रेखाएँ नहीं)। और समकक्ष का मतलब है कि छोटे समाधान में पिछले समाधान की तुलना में अधिक समय या स्थान की जटिलता नहीं होनी चाहिए।

इसका मतलब यह है कि सभी समान रूप से दोहराए जाने वाले पैटर्न को उचित अमूर्त में निकाला जाना चाहिए: समान कोड ब्लॉक? इसे कार्य करने के लिए निकालें। चर जो एक साथ होते प्रतीत होते हैं? उन्हें एक संरचना / वर्ग में निकालें। वे वर्ग जिनके सदस्य केवल प्रकार से भिन्न होते हैं? आपको एक जेनेरिक चाहिए। आप एक ही बात को कई स्थानों पर याद करते हैं? शुरुआत में गणना करें और एक चर में मूल्य संग्रहीत करें। ऐसा करने से परिणाम कम हो जाएंगे। यह मूल रूप से DRY सिद्धांत है।

हम इस बात से भी सहमत हो सकते हैं कि अप्रयुक्त अमूर्त को हटा दिया जाना चाहिए: कक्षाएं, फ़ंक्शंस जिनकी अब आवश्यकता नहीं है, मृत कोड हैं, इसलिए इसे हटा दिया जाना चाहिए। यदि हमें कभी भी इसे बहाल करने की आवश्यकता होगी तो संस्करण नियंत्रण याद रहेगा।

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

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


0

यह सभी व्यक्तिपरक है और कोड के आधार पर कोई भी माप अंततः अप्रासंगिक है। अंत में यह मांगों को पूरा करने की आपकी क्षमता के नीचे आता है। क्या आप अभी भी उन सुविधाओं को वितरित कर सकते हैं जो अनुरोध किए जा रहे हैं और यदि आप कर सकते हैं, तो वे परिवर्तन आपके पास कितनी बार वापस आएंगे क्योंकि कुछ अभी तक सही नहीं हैं और वे मुद्दे कितने गंभीर हैं?

मैंने अभी (पुनः) परिभाषित स्थिरता को परिभाषित किया है लेकिन यह अभी भी व्यक्तिपरक है। दूसरी ओर, यह सब इतना मायने नहीं रखता है। हमें बस अपने ग्राहक को संतुष्ट करने और उसका आनंद लेने की आवश्यकता है, यही हम लक्ष्य कर रहे हैं।

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.