अंतिम पंक्ति प्रभाव

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

परिचय

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



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



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



विशेष रूप से, मैंने संचित सामग्री पर कोई शोध नहीं किया। फिर भी, एक नियमितता इतनी स्पष्ट रूप से प्रकट होती है कि मैंने इसे और अधिक विस्तार से अध्ययन करने का फैसला किया। लेखों में मुझे अक्सर "अंतिम पंक्ति पर ध्यान देना" लिखना होता है। मैंने तय किया कि यह आकस्मिक नहीं था।

अंतिम पंक्ति प्रभाव

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



अब पैटर्न के बारे में। मुझे पता चला कि कोड के बहुत अंतिम कॉपी किए गए ब्लॉक में अक्सर एक गलती की जाती है।



एक सरल संक्षिप्त उदाहरण:

inline Vector3int32& operator+=(const Vector3int32& other) { x += other.x; y += other.y; z += other.y; return *this; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

लाइन पर ध्यान दें "z + = other.y;"। वे इसमें 'y' को 'z' बदलना भूल गए।



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



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



अब कुछ संख्या।



त्रुटि आधार का अध्ययन करने के बाद, मैंने 84 कोड अंशों की पहचान की, जो मुझे लगता है, कॉपी-पेस्ट का उपयोग करके लिखे गए थे। इनमें से, 41 खंडों में कॉपी किए गए ब्लॉकों के बीच में एक त्रुटि है। यहाँ एक उदाहरण है:

 strncmp(argv[argidx], "CAT=", 4) && strncmp(argv[argidx], "DECOY=", 6) && strncmp(argv[argidx], "THREADS=", 6) && strncmp(argv[argidx], "MINPROB=", 8)) {
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

स्ट्रिंग की लंबाई "THREADS =" 6 नहीं है, लेकिन 8 वर्ण हैं।



शेष 43 मामलों में, हाल ही में कॉपी किए गए ब्लॉक में एक त्रुटि पाई गई थी।



पहली नज़र में, संख्या 43 41 से थोड़ा अधिक है। लेकिन ध्यान रखें कि एक ही प्रकार के कुछ ब्लॉक हैं। और त्रुटि पहले, दूसरे, पांचवें या यहां तक ​​कि दसवें ब्लॉक में हो सकती है। हमें ब्लॉकों में त्रुटियों का एक अपेक्षाकृत समान वितरण और अंत में एक तेज उछाल मिलता है।



औसतन, मैंने यह लिया कि एक ही प्रकार के ब्लॉक की संख्या 5 है।



यह पता चलता है कि 41 त्रुटियों के लिए पहले 4 ब्लॉक खाते हैं। या प्रति ब्लॉक लगभग 10 त्रुटियां।



43 त्रुटियों के लिए अंतिम पांचवां ब्लॉक खाता है!



स्पष्टता के लिए, आप इस तरह के अनुमानित कार्यक्रम का निर्माण कर सकते हैं:







चित्रा 1. समान कोड के पांच ब्लॉकों में त्रुटियों की संख्या का अनुमानित ग्राफ।



यह पता चला है:



अंतिम कॉपी किए गए ब्लॉक में गलती करने की संभावना किसी भी अन्य की तुलना में 4 गुना अधिक है।



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

उदाहरण

यह पाठकों को समझाने के लिए बनी हुई है कि ये मेरी कल्पनाएँ नहीं हैं, बल्कि जीवन की वास्तविकताएँ हैं। इसके लिए, मैं उन उदाहरणों का प्रदर्शन करूँगा जो मेरे शब्दों की पुष्टि करेंगे।



बेशक, मैं सभी उदाहरण नहीं दूंगा। मैं खुद को सबसे सरल या सबसे अधिक सांकेतिक तक सीमित करूंगा।

स्रोत इंजन एसडीके

 inline void Init( float ix=0, float iy=0, float iz=0, float iw = 0 ) { SetX( ix ); SetY( iy ); SetZ( iz ); SetZ( iw ); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अंत में, आपको सेटडब्ल्यू () फ़ंक्शन को कॉल करना होगा।

क्रोमियम

 if (access & FILE_WRITE_ATTRIBUTES) output.append(ASCIIToUTF16("\tFILE_WRITE_ATTRIBUTES\n")); if (access & FILE_WRITE_DATA) output.append(ASCIIToUTF16("\tFILE_WRITE_DATA\n")); if (access & FILE_WRITE_EA) output.append(ASCIIToUTF16("\tFILE_WRITE_EA\n")); if (access & FILE_WRITE_EA) output.append(ASCIIToUTF16("\tFILE_WRITE_EA\n")); break;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अंतिम और प्रथागत ब्लॉक मेल खाते हैं।

ReactOS

 if (*ScanString == L'\"' || *ScanString == L'^' || *ScanString == L'\"')
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

मल्टी चोरी ऑटो

 class CWaterPolySAInterface { public: WORD m_wVertexIDs[3]; }; CWaterPoly* CWaterManagerSA::CreateQuad (....) { .... pInterface->m_wVertexIDs [ 0 ] = pV1->GetID (); pInterface->m_wVertexIDs [ 1 ] = pV2->GetID (); pInterface->m_wVertexIDs [ 2 ] = pV3->GetID (); pInterface->m_wVertexIDs [ 3 ] = pV4->GetID (); .... }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अंतिम पंक्ति जड़ता द्वारा लिखी गई है और यह बहुत ही शानदार है। सरणी में केवल 3 तत्व हैं।

स्रोत इंजन एसडीके

 intens.x=OrSIMD(AndSIMD(BackgroundColor.x,no_hit_mask), AndNotSIMD(no_hit_mask,intens.x)); intens.y=OrSIMD(AndSIMD(BackgroundColor.y,no_hit_mask), AndNotSIMD(no_hit_mask,intens.y)); intens.z=OrSIMD(AndSIMD(BackgroundColor.y,no_hit_mask), AndNotSIMD(no_hit_mask,intens.z));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अंतिम पंक्ति में, वे "BackgroundColor.z" के साथ "BackgroundColor.y" को बदलना भूल गए।

ट्रांस-प्रोटीन पाइपलाइन

 void setPepMaxProb(....) { .... double max4 = 0.0; double max5 = 0.0; double max6 = 0.0; double max7 = 0.0; .... if ( pep3 ) { ... if ( use_joint_probs && prob > max3 ) ... } .... if ( pep4 ) { ... if ( use_joint_probs && prob > max4 ) ... } .... if ( pep5 ) { ... if ( use_joint_probs && prob > max5 ) ... } .... if ( pep6 ) { ... if ( use_joint_probs && prob > max6 ) ... } .... if ( pep7 ) { ... if ( use_joint_probs && prob > max6 ) ... } .... }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अंतिम स्थिति में, वे "प्रोब> मैक्स 6" को "प्रोब> मैक्स 7" से बदलना भूल गए।

SeqAn

 inline typename Value<Pipe>::Type const & operator*() { tmp.i1 = *in.in1; tmp.i2 = *in.in2; tmp.i3 = *in.in2; return tmp; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

SlimDX

 for( int i = 0; i < 2; i++ ) { sliders[i] = joystate.rglSlider[i]; asliders[i] = joystate.rglASlider[i]; vsliders[i] = joystate.rglVSlider[i]; fsliders[i] = joystate.rglVSlider[i]; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अंतिम पंक्ति rglFSlider सरणी का उपयोग करने के लिए थी।

क्यूटी

 if (repetition == QStringLiteral("repeat") || repetition.isEmpty()) { pattern->patternRepeatX = true; pattern->patternRepeatY = true; } else if (repetition == QStringLiteral("repeat-x")) { pattern->patternRepeatX = true; } else if (repetition == QStringLiteral("repeat-y")) { pattern->patternRepeatY = true; } else if (repetition == QStringLiteral("no-repeat")) { pattern->patternRepeatY = false; pattern->patternRepeatY = false; } else { //TODO: exception: SYNTAX_ERR }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

बहुत आखिरी ब्लॉक में, वे 'patternRepeatX' के बारे में भूल गए। होना चाहिए:

 pattern->patternRepeatX = false; pattern->patternRepeatY = false;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ReactOS

 const int istride = sizeof(tmp[0]) / sizeof(tmp[0][0][0]); const int jstride = sizeof(tmp[0][0]) / sizeof(tmp[0][0][0]); const int mistride = sizeof(mag[0]) / sizeof(mag[0][0]); const int mjstride = sizeof(mag[0][0]) / sizeof(mag[0][0]);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

चर 'mjstride' हमेशा एक के बराबर होगा। अंतिम पंक्ति इस तरह होनी चाहिए:

 const int mjstride = sizeof(mag[0][0]) / sizeof(mag[0][0][0]);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

मोज़िला फ़ायरफ़ॉक्स

 if (protocol.EqualsIgnoreCase("http") || protocol.EqualsIgnoreCase("https") || protocol.EqualsIgnoreCase("news") || protocol.EqualsIgnoreCase("ftp") || <<<--- protocol.EqualsIgnoreCase("file") || protocol.EqualsIgnoreCase("javascript") || protocol.EqualsIgnoreCase("ftp")) { <<<---
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अंत में संदिग्ध लाइन "ftp"। इस लाइन की तुलना पहले ही की जा चुकी है।

भूकंप-III-अखाड़ा

 if (fabs(dir[0]) > test->radius || fabs(dir[1]) > test->radius || fabs(dir[1]) > test->radius)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हमने dir सेल [2] से मूल्य की जांच नहीं की।

बजना

 return (ContainerBegLine <= ContaineeBegLine && ContainerEndLine >= ContaineeEndLine && (ContainerBegLine != ContaineeBegLine || SM.getExpansionColumnNumber(ContainerRBeg) <= SM.getExpansionColumnNumber(ContaineeRBeg)) && (ContainerEndLine != ContaineeEndLine || SM.getExpansionColumnNumber(ContainerREnd) >= SM.getExpansionColumnNumber(ContainerREnd)));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

बहुत ही अंत में, "SM.getExpansionColumnNumber (कंटेनर)) की अभिव्यक्ति खुद की तुलना में है।

MongoDB

 bool operator==(const MemberCfg& r) const { .... return _id==r._id && votes == r.votes && h == rh && priority == r.priority && arbiterOnly == r.arbiterOnly && slaveDelay == r.slaveDelay && hidden == r.hidden && buildIndexes == buildIndexes; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

"आर" के बारे में बहुत अंत में भूल गए।

अवास्तविक इंजन ४

 static bool PositionIsInside(....) { return Position.X >= Control.Center.X - BoxSize.X * 0.5f && Position.X <= Control.Center.X + BoxSize.X * 0.5f && Position.Y >= Control.Center.Y - BoxSize.Y * 0.5f && Position.Y >= Control.Center.Y - BoxSize.Y * 0.5f; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अंतिम पंक्ति में 2 संपादन करना भूल गए। सबसे पहले, "> =" को "<= दूसरा" से बदलें, माइनस को प्लस से बदलें।

क्यूटी

 qreal x = ctx->callData->args[0].toNumber(); qreal y = ctx->callData->args[1].toNumber(); qreal w = ctx->callData->args[2].toNumber(); qreal h = ctx->callData->args[3].toNumber(); if (!qIsFinite(x) || !qIsFinite(y) || !qIsFinite(w) || !qIsFinite(w))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सबसे हाल के qIsFinite फ़ंक्शन कॉल में, आपको तर्क के रूप में 'h' वेरिएबल का उपयोग करने की आवश्यकता होती है।

OpenSSL

 if (!strncmp(vstart, "ASCII", 5)) arg->format = ASN1_GEN_FORMAT_ASCII; else if (!strncmp(vstart, "UTF8", 4)) arg->format = ASN1_GEN_FORMAT_UTF8; else if (!strncmp(vstart, "HEX", 3)) arg->format = ASN1_GEN_FORMAT_HEX; else if (!strncmp(vstart, "BITLIST", 3)) arg->format = ASN1_GEN_FORMAT_BITLIST;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

"BITLIST" स्ट्रिंग की लंबाई 3 नहीं है, लेकिन 7 वर्ण हैं।



हमें इस पर ध्यान दें। मुझे लगता है कि उपरोक्त उदाहरण पर्याप्त से अधिक हैं।

निष्कर्ष

इस लेख में, आपने सीखा कि कॉपी-पेस्ट का उपयोग करते समय, अंतिम कॉपी किए गए ब्लॉक में त्रुटि करने की संभावना किसी भी अन्य की तुलना में 4 गुना अधिक है।



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



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

यह लेख अंग्रेजी में है।

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