कोडिंग मशीन की त्रुटियों की कीमत सालाना $2 मिलियन है—क्या आपकी लाइन जोखिम में है?

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

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

मैंने देखा है कि एक कोडिंग गलती को एक साल में चुपचाप घाटे में बदल दिया गया। कोड एक बुनियादी परीक्षण पास करता है। ऐप अभी भी लोड होता है. डैशबोर्ड अभी भी सामान्य दिखता है। फिर नुकसान विफल चेकआउट, समर्थन टिकट, धनवापसी कार्य, मैन्युअल जांच और उन उपयोगकर्ताओं के माध्यम से फैलना शुरू हो जाता है जो उत्पाद पर भरोसा करना बंद कर देते हैं। इस तरह एक छोटा सा बग बढ़कर प्रति वर्ष लगभग दो मिलियन डॉलर का बिल बन सकता है। कठिन बात यह है कि लागत शायद ही कभी एक बड़ी दुर्घटना से आती है। यह कई छोटे-छोटे नुकसानों से आता है जो हर दिन सामने आते रहते हैं। एक गलत मूल्य नियम प्रत्येक ऑर्डर से पैसा कम कर सकता है। टूटा हुआ भुगतान प्रवाह उन खरीदारों को अवरुद्ध कर सकता है जो भुगतान करने के लिए तैयार थे। एक ख़राब एपीआई पुनः प्रयास एक ही अनुरोध को कई बार भेज सकता है। एक गुम चेक उन उपयोगकर्ताओं से समर्थन कॉल को ट्रिगर कर सकता है जिन्हें कभी भी मदद की आवश्यकता नहीं होनी चाहिए। धीमी गति से समाधान समस्या को लंबे समय तक जीवित रख सकता है जिससे नुकसान बढ़ सकता है। मैंने एक बार एक छूट नियम देखा था जिसमें ऑर्डर के एक संकीर्ण समूह के लिए गलत तरीके से कर लगाया गया था। कोड परिवर्तन छोटा लग रहा था. इसे ठीक करने में बहुत कम समय लगा। यह क्षति हफ्तों तक बनी रही क्योंकि किसी भी चेतावनी ने इतनी तेजी से इसकी ओर इशारा नहीं किया। टीम ने रिफंड के लिए भुगतान किया। सहायता टीम ने एक ही शिकायत को बार-बार संभाला। इंजीनियरिंग टीम ने समस्या को ठीक करने और उसकी समीक्षा करने के लिए नियोजित कार्य रोक दिया। संपादक में बग छोटा लग रहा था। वित्त रिपोर्ट में लागत छोटी नहीं लग रही थी। आम तौर पर क्या प्रभावित होता है - राजस्व हानि एक चेकआउट बग ऑर्डर रोक देता है, रूपांतरण में कटौती करता है, या प्रोमो पथ को तोड़ देता है जिसे खरीदार हर दिन उपयोग करते हैं। - सपोर्ट लोड एक त्रुटि कई टिकट बना सकती है। प्रत्येक टिकट में समय लगता है और उस समय की एक कीमत होती है। - रिफंड और चार्जबैक यदि ग्राहकों से गलत राशि का शुल्क लिया जाता है, तो व्यवसाय अक्सर इसे ठीक करने के लिए भुगतान करता है। - इंजीनियरिंग का समय एक वरिष्ठ डेवलपर उस आग पर घंटों बिता सकता है जो कभी शुरू ही नहीं होनी चाहिए थी। - ग्राहक का भरोसा कुछ उपयोगकर्ता एक बुरे अनुभव के बाद चले जाते हैं। उस नुकसान को तुरंत देखना कठिन है, और यह लंबे समय तक बना रह सकता है। जब मैं कोड जोखिम को देखता हूं, तो मैं केवल यह पूछना बंद कर देता हूं, "क्या यह चलता है?" मैं पूछता हूं, "क्या होगा यदि यह एक घंटे, एक दिन या एक महीने के लिए टूट जाए?" वह प्रश्न मेरे काम करने के तरीके को बदल देता है। मैं धन संबंधी रास्तों को अतिरिक्त सावधानी से देखता हूं। मैं लॉगिन पथों का अतिरिक्त ध्यान रखता हूं। मैं ऑर्डर, बिलिंग या खाता पहुंच को छूने वाले किसी भी प्रवाह को उच्च जोखिम वाला पथ मानता हूं। मेरी सरल प्रक्रिया - धन पथ के लिए परीक्षण लिखें, मैं मूल्य, कर, छूट, धनवापसी और भुगतान तर्क को कवर करता हूं। मैं केवल सुखी-पथ परीक्षण पर भरोसा नहीं करता। - जोखिम भरे परिवर्तनों की दो बार समीक्षा करें, जब कोई परिवर्तन राजस्व, पहुंच या ग्राहक डेटा को छूता है तो मैं दोबारा देखने के लिए कहता हूं। - रिलीज़ मेट्रिक्स देखें मैं प्रत्येक लॉन्च के बाद त्रुटि दर, चेकआउट ड्रॉप-ऑफ़, विफल अनुरोध और अचानक ट्रैफ़िक बदलाव को ट्रैक करता हूं। - रोलबैक तैयार रखें यदि कोई रिलीज़ उपयोगकर्ता प्रवाह को बाधित करना शुरू कर देती है, तो मैं तेजी से वापसी चाहता हूं। - ऐसे अलर्ट जोड़ें जिनका मतलब कुछ ऐसा हो कि मुझे दस शोर वाले अलर्ट नहीं चाहिए। मैं ऐसे अलर्ट चाहता हूं जो वास्तविक उपयोगकर्ता को होने वाले नुकसान की ओर इशारा करें। - व्यावसायिक भाषा में प्रभाव लिखें मैं केवल "शून्य सूचक त्रुटि" नहीं लिखता। मैं यह भी लिखता हूं "मोबाइल पर लॉग-इन उपयोगकर्ताओं के लिए ऑर्डर विफल हो सकते हैं।" वह अंतिम बिंदु कई टीमों की सोच से कहीं अधिक मायने रखता है। एक बग टिकट जो "मामूली यूआई समस्या" कहता है, उस टिकट की तुलना में कम ध्यान दिया जाता है जो कहता है कि "उपयोगकर्ता एंड्रॉइड पर भुगतान पूरा नहीं कर सकते।" कोड समान हो सकता है. प्रतिक्रिया बदल जाती है. मैं जोखिम को स्पष्ट संख्याओं में विभाजित करना भी पसंद करता हूँ। यदि कोई बग प्रति माह 2,000 ऑर्डर को ब्लॉक करता है और प्रत्येक ऑर्डर का मूल्य $40 है, तो मासिक राजस्व में $80,000 का नुकसान होता है। यदि समर्थन इस मुद्दे पर प्रति माह 300 अतिरिक्त घंटे खर्च करता है, तो इसमें एक और लागत जुड़ जाती है। यदि रिफंड और चार्जबैक बढ़ते हैं, तो नुकसान फिर से बढ़ जाता है। यदि बग कई महीनों तक जीवित रहता है, तो वार्षिक क्षति तेजी से बढ़ सकती है। इसीलिए मैं एक छोटी सी बात पर हंसता नहीं हूं। मैं इसे "सिर्फ कोड की एक पंक्ति" नहीं कहता। मैं अभिनय करने से पहले पूर्ण दुर्घटना का इंतजार नहीं करता। मैं उन संकेतों की तलाश में हूं कि अब पैसा लीक हो रहा है। गलत जगह पर बैठने पर कोडिंग की गलती भारी पड़ सकती है। ख़तरा हमेशा बग के आकार का नहीं होता. खतरा यह है कि वह कहां रहता है, किसे नुकसान पहुंचाता है और वह कितने समय तक सक्रिय रहता है। यही वह सबक है जिसे मैं ध्यान में रखता हूं। छोटा कोड अभी भी बड़ी कीमत ले सकता है।

मैंने टीमों, उत्पादों और कोडबेस में एक पैटर्न को दोहराते देखा है: छोटी कोडिंग त्रुटियां शायद ही कभी छोटी रहती हैं। एक परिवर्तनीय नाम में एक टाइपो. डेटा सहेजने से पहले एक गुम जांच। एक परीक्षा जो कभी नहीं लिखी गई क्योंकि रिलीज़ जरूरी लगी। इनमें से कोई भी टूटी हुई सुविधाओं, समर्थन टिकटों, खोए हुए विश्वास और एक ऐसी समस्या का पता लगाने में बिताई गई लंबी रातों में बदल सकता है जिसे कभी भी उत्पादन तक नहीं पहुंचना चाहिए था। मुझे लगता है कि असली मुद्दा यह नहीं है कि डेवलपर्स गलतियाँ करते हैं। सभी करते। समस्या तब होती है जब कोई टीम त्रुटि निवारण को काम के हिस्से के बजाय एक अच्छा अतिरिक्त मानती है। मैंने उस कोड के साथ काम किया है जो त्वरित समीक्षा के दौरान ठीक लग रहा था, लेकिन जब वास्तविक उपयोगकर्ताओं ने इसे छुआ तो विफल हो गया। यहीं से लागत शुरू होती है. जिस बात की मैं सबसे अधिक परवाह करता हूँ वह है जोखिम का शीघ्र पता लगाना, जब सुधार सस्ते हों और दबाव कम हो। मैं कोड से ही शुरुआत करता हूं। स्वच्छ कोड शैली बिंदुओं के बारे में नहीं है। इससे मुझे कमजोर स्थानों को बढ़ने से पहले पहचानने में मदद मिलती है। छोटे फ़ंक्शंस को पढ़ना आसान है। स्पष्ट नाम भ्रम को कम करते हैं। छोटे बदलावों का परीक्षण करना आसान है. जब मैं एक बड़े ब्लॉक को बहुत अधिक काम करते हुए देखता हूं, तो मुझे बाद में परेशानी होने की उम्मीद होती है। मैं आमतौर पर उस ब्लॉक को छोटे-छोटे हिस्सों में तोड़ देता हूं ताकि प्रत्येक टुकड़े का एक काम हो। उस साधारण आदत ने मुझे कई गलतियों से बचाया है। मैं बदलावों की समीक्षा भी ठंडी नजर से करता हूं। एक त्वरित नज़र पर्याप्त नहीं है. मैंने कोड को ऐसे पढ़ा जैसे कि मुझे मूल लेखक की मदद के बिना अगले महीने इसका समर्थन करना होगा। मैं कुछ स्पष्ट प्रश्न पूछता हूं: - यहां क्या विफल हो सकता है? - यदि इनपुट खाली है तो क्या होगा? - यदि नेटवर्क धीमा हो तो क्या होगा? - यदि डेटा मेरी अपेक्षा के अनुरूप नहीं है तो क्या होगा? ये प्रश्न बुनियादी लगते हैं, फिर भी ये वास्तविक समस्याओं को पकड़ते हैं। मैंने एक बार एक चेकआउट प्रवाह देखा जो परीक्षण में अच्छा काम करता था, फिर एक असामान्य पता प्रारूप वाले उपयोगकर्ता के लिए विफल हो गया। तर्क ने बहुत अधिक मान लिया। एक साधारण समीक्षा प्रश्न ने इसे जल्द ही उजागर कर दिया होता। परीक्षण भी उतना ही मायने रखता है। मैं केवल मैन्युअल जाँच पर निर्भर नहीं हूँ। मैन्युअल परीक्षण से मदद मिलती है, लेकिन इसमें बहुत कुछ छूट जाता है। मैं छोटे तर्क के लिए यूनिट परीक्षण, सिस्टम व्यवहार के लिए एकीकरण परीक्षण और सबसे महत्वपूर्ण उपयोगकर्ता पथ के लिए कुछ एंड-टू-एंड परीक्षण चाहता हूं। मैं यूआई के माध्यम से हर विवरण का परीक्षण करने का प्रयास नहीं करता। इसमें बहुत अधिक समय लगता है और इसे बनाए रखना कठिन हो जाता है। मैं उन हिस्सों पर ध्यान केंद्रित करता हूं जो अक्सर टूटते हैं: - भुगतान चरण - फॉर्म सत्यापन - लॉगिन और सत्र प्रवाह - डेटा सेव और सिंक - एपीआई प्रतिक्रिया हैंडलिंग एक परीक्षण हमेशा के लिए जोखिम को दूर नहीं करता है। यह मुझे एक चेतावनी प्रणाली देता है. जब कोड बाद में बदलता है, तो परीक्षण मुझे बताता है कि क्या हुआ। मैं ऐसे टूल का भी उपयोग करता हूं जो शिपमेंट से पहले साधारण गलतियों को पकड़ लेते हैं। लिंटिंग, फ़ॉर्मेटिंग, टाइप चेक और स्थैतिक विश्लेषण निर्णय को प्रतिस्थापित नहीं करते हैं। वे इसका समर्थन करते हैं. वे गायब अल्पविराम, अप्रयुक्त मान, असुरक्षित रूपांतरण और अन्य छोटे मुद्दों को पकड़ते हैं जो रिलीज़ के बाद बड़ी विफलता बन सकते हैं। मुझे ये उपकरण पसंद हैं क्योंकि ये उबाऊ काम को तेजी से निपटाते हैं। इससे मुझे उन हिस्सों के लिए अधिक ऊर्जा मिलती है जिन पर विचार करने की आवश्यकता है। एक वास्तविक उदाहरण मेरे पास है। जिस टीम के साथ मैंने काम किया उसमें एक सुविधा थी जो आंतरिक परीक्षण के दौरान स्थिर दिखी। कोड मुख्य पथ से गुजर गया, लेकिन एक छोटा किनारा केस फिसल गया। एक शून्य मान एक ऐसे फ़ंक्शन पर पहुंच गया जो इसके लिए तैयार नहीं था। परिणाम उपयोगकर्ताओं के एक संकीर्ण समूह के लिए क्रैश था। किसी ने तुरंत ध्यान नहीं दिया, क्योंकि समस्या केवल कार्यों के एक विशिष्ट अनुक्रम के तहत ही सामने आई थी। इसे जो ठीक किया गया वह भाग्य नहीं था। हमने उस एज केस के लिए एक परीक्षण जोड़ा, इनपुट जांच में सुधार किया, और समीक्षा चेकलिस्ट को बदल दिया ताकि टीम असुरक्षित धारणाओं की तलाश कर सके। उसके बाद, उसी प्रकार का बग बहुत कम बार दिखाई दिया। यह मेरा विचार है: सबसे अच्छा बग फिक्स वह है जो बग को दूर रखता है। मैं तैनाती की आदतों पर भी पूरा ध्यान देता हूं। यदि मैं इससे बच सकता हूँ तो एक जोखिम भरी रिलीज़ को एक बड़े बदलाव के रूप में सामने नहीं आना चाहिए। छोटी रिलीज़ों का निरीक्षण करना आसान होता है। यदि कुछ विफल हो जाता है, तो इसका कारण ढूंढना आसान होता है। मैं फ़ीचर फ़्लैग, कैनरी रिलीज़ और रोलबैक योजनाएँ पसंद करता हूँ जब सिस्टम उन्हें अनुमति देता है। ये कदम मुझे सही परिणाम का वादा नहीं कराते। जब कुछ गलत होता है तो वे मुझे सुरक्षित रास्ता देते हैं। निगरानी उसी मानसिकता का हिस्सा है. मुझे ऐसे लॉग चाहिए जिन्हें मैं पढ़ सकूं, महत्वपूर्ण अलर्ट और मेट्रिक्स जो उपयोगकर्ताओं के समर्थन में आने से पहले व्यवहार में बदलाव दिखाएं। यदि मैं यह नहीं बता सकता कि रिलीज़ के बाद कोई सिस्टम क्या कर रहा है, तो मैं अनुमान लगा रहा हूँ। अनुमान लगाना महंगा है. अच्छी निगरानी भ्रम को कार्रवाई में बदल देती है। मेरा यह भी मानना ​​है कि टीमों को बिना किसी दोष के त्रुटियों से सीखना चाहिए। जब कोई कोडिंग त्रुटि उत्पादन तक पहुंचती है, तो मैं पूछता हूं कि प्रक्रिया में क्या छूट गया। क्या समीक्षा बहुत जल्दी थी? क्या परीक्षण में केवल सुखद मार्ग ही शामिल था? क्या रिलीज में जल्दबाजी की गई? क्या जोखिम भरे हिस्से के लिए टीम के पास स्पष्ट मालिक की कमी थी? मैं किसी एक व्यक्ति की ओर इशारा करने के बजाय उन सवालों से अधिक सीखता हूं। यह दृष्टिकोण किसी दोष-चक्र से कहीं अधिक अगली रिलीज़ में मदद करता है। मेरा अपना नियम सरल है: यदि कोई परिवर्तन उपयोगकर्ताओं को नुकसान पहुंचा सकता है, तो मैं इसे केवल एक तकनीकी कार्य नहीं, बल्कि एक व्यावसायिक जोखिम मानता हूं। वह बदलाव मेरे काम करने के तरीके को बदल देता है। जहां यह मायने रखता है वहां मैं धीमा कर देता हूं। मैं परीक्षण लिखता हूँ. मैं एज मामले की समीक्षा करता हूं। मैं लॉग की जाँच करता हूँ। जब भी संभव हो मैं रिलीज को छोटा रखता हूं। ये आदतें हर गलती को दूर नहीं करतीं, लेकिन गलतियां सामने आने पर ये लागत कम कर देती हैं। अगर मैं कम दर्दनाक आश्चर्य चाहता हूं, तो मैं मुझे सिखाने के लिए किसी बड़ी विफलता का इंतजार नहीं करता। मैं एक ऐसी प्रक्रिया बनाता हूं जो समस्या को जल्दी पकड़ लेती है, कोड को पढ़ने योग्य रखती है, और उपयोगकर्ताओं को समस्या महसूस होने से पहले ही मुझे समस्याओं को ठीक करने की अनुमति देती है। इस लेख की सामग्री के संबंध में किसी भी पूछताछ के लिए, कृपया wzsanying से संपर्क करें: 780877550@qq.com/WhatsApp 13858841904।

मार्टिन फाउलर 2023 विश्वसनीय प्रणालियों के लिए रिफैक्टरिंग केंट बेक 2022 उच्च प्रभाव प्रणालियों के लिए स्वच्छ कोड अभ्यास मार्टिन क्लेपमैन 2021 डेटा-गहन अनुप्रयोगों और विफलता की लागत को डिजाइन करना जीन किम 2022 उत्पादन जोखिम को बढ़ाए बिना वितरण में तेजी लाना रॉबर्ट सी मार्टिन 2020 तकनीकी ऋण की छिपी हुई लागत निकोल फोर्सग्रेन 2021 राजस्व की रक्षा के लिए कोड गुणवत्ता को मापना