Debugging: Finding It Yourself

பெரும்பாலான புதியவர்கள் ஒரு பிழைக்கு சுவர் போல நடந்துகொள்கிறார்கள். அவர்கள் அதை அடிக்கிறார்கள், நிறுத்துகிறார்கள், மேலே ஏற அவர்களுக்கு பதிலாக செய்ய வேறொருவரைக் கேட்கிறார்கள். உண்மையில் திறமை உருவாக்கும் பழக்கம் வேறுபட்டது: நீங்கள் ஒரு பிழையை பதிலைக் கண்டறியக்கூடிய கேள்விபோல் நடத்த கற்றுக்கொள்கிறீர்கள், நீங்கள் கேட்பதற்கு முன் அதைக் கண்டுபிடி.

பிழை செய்தியை சாட்சியமாக படியுங்கள், சப்தம் அல்ல

Stack traces பெரும்பாலும் தவிர்க்கப்படுகின்றன, ஏனெனில் அவை பயமாக தெரிகின்றன. ஆனால் அவை வழக்கமாக சரியாக எங்கே மற்றும் ஏன் ஏதாவது உடைந்தது என்று சொல்லும். Python-ல் TypeError: 'NoneType' object is not subscriptable பெற்றால், அது சீரற்ற விசிறல் அல்ல — இது மாறி நீங்கள் பட்டியல் அல்லது dict வைத்திருக்க எதிர்பார்த்திருந்தீர்கள் உண்மையில் None என்று பொருள். வரி எண் உங்களுக்கு சொல்லும். உங்கள் வேலை அந்த வரிக்கு பின்னோக்கி தேடலாவது மற்றும் மதிப்பு இங்கு அமைக்கப்பட்டிருக்க வேண்டும் ஆனால் இல்லை என்று கண்டறிய வேண்டும்.

অনলைনில் ஏதாவது தேடுவதற்கு முன் இதைச் செய்யுங்கள்: traceback-ன் கடைசி வரி முதலில் படியுங்கள், பிறகு மேலே வேலை செய்யுங்கள். கடைசி வரி வழக்கமாக உண்மையான விதிவிலக்கைப் பெயரிடுகிறது. அதற்கு மேலே உள்ள வரிகள் நிலைய வரிசையைக் காட்டுகிறது.

அதை வேண்டுமென்றே மீண்டு உண்டாக்குங்கள்

ஒரு பிழை சில சமயங்களில் மட்டுமே தோன்றினால், நீங்கள் இன்னும் அதைப் புரிந்துகொள்ளவில்லை. கোடைத் தொடுவதற்கு முன், அதைச் சரியாக நடக்க செய்ய முயற்சி செய்யுங்கள். ஒரு முறையில் ஒரு உள்ளீடை மாற்றுங்கள். என்று அது খালியப் பட்டியலுடன் தோல்வியுறும் ஆனால் முழு ஒன்றுடன் இல்லை? என்று அது ஒரு செயல்பாட்டிற்கு இரண்டாம் அழைப்பிற்கு மட்டுமே தோல்வியுறும், முதல் இல்லை? ஒரு பிழை நீங்கள் கட்டளை மீது மீண்டு உண்டாக்கக்கூடிய 80% தீர்க்கப்பட்ட ஒரு பிழை, ஏனெனில் இப்போது நீங்கள் ஒரு சரி உண்மையில் வேலை செய்தது என்று சோதிக்க முடியும் நினைப்பாக மாறாக.

சிக்கலைப் பாதியாக கூறு, பிறகு மீண்டும் பாதி

Binary search வெறும் வரிசைப்படுத்தப்பட்ட வரிசைகளுக்கு அல்ல — இது ஒரு நீண்ட செயல்பாடு அல்லது pipeline-ல் உடைந்த குறியீட்டைக் கண்டறிய வேகமான வழி. உங்கள் தர্க்கத்தின் இரண்டாம் பாதியை கருத்து செய்யுங்கள் அல்லது பொய்யாக்குங்கள் மற்றும் முதல் பாதி இன்னும் பிழை உত்பாதிக்கிறதா சரிபார்க்கவும். ஆம் என்றால், சிக்கல் முதல் பாதிதான். இல்லை என்றால், இது இரண்டாম பாதி. மீண்டும் செய்யுங்கள். இது 200-வரி script-க்கு பணி செய்கிறது அளவுக்கு இது இரண்டு-stage data pipeline-க்கு வேலை செய்கிறது நீங்கள் ஒவ்வொரு stage-ல் print() அல்லது df.head() உடன் outputs சரிபார்க்கிறீர்கள்.

இது வரிகளை மாறாக மாற்றி மீண்டும் চালிப்பதை விட சிறந்தது, அது பெரும்பாலான மக்கள் அழுத்தத்தின் கீழ் செய்வது மற்றும் அது சேமிப்பதை விட மிகவும் கூடுதல் நேரம் வீணாக செய்கிறது.

debugger-ஐ பயன்படுத்தவும் print() இற்கு பதிலாக print() சப்தம் நிறுத்த போது

print() statements எளிய cases-க்கு சரி, ஆனால் ஒரு முறை நீங்கள் பல செயல்பாட்டு அழைப்புக்கள் முழுவதும் நிலை தொடர்ந்திருக்கிறீர்கள், ஒரு உண்மையான debugger உண்மையான நேரம் சேமிக்கிறது. Python-ல், வீழ்த்து import pdb; pdb.set_trace() சரியாக சந்தேகமான வரிக்கு முன், script ஓடை, நீங்கள் ஒரு live prompt பெறுங்கள் நீங்கள் மாறிகள் inspect, n உடன் வரி மூலம் வரி step, மற்றும் s உடன் செயல்பாட்டு அழைப்பிலிருந்து step. VS Code-ன் built-in debugger அதே விஷயத்தை breakpoints உடன் நீங்கள் type மாறாக click செய்கிறீர்கள். என்ற வழி, goal ஒன்றே: உங்கள் நிரல்-ன் உண்மையான நிலை பார்க்கவும் நீங்கள் அது சாத்தியமாக என்று நினைப்பு இல்லாக.

உங்கள் செயல்-ன் மீதியிலிருந்து தனிமை செய்யுங்கள்

ஒரு பிழை ஒரு பெரிய codebase உள்ளே நடக்கிறது என்றால், பெரிய codebase உள்ளே அதை debug செய்ய வேண்ட அல்ல. உறவான செயல்பாடு ஒரு fresh கோப்பிற்கு fake, minimal உள்ளீடு உடன் copy பிழை அதே தோல்வி trigger. பிழை மறைந்து போனால், ஏதாவது சுற்றுப்புற context பற்றி — ஒரு global மாறி, ஒரு import, stale நிலை — உண்மையான cause, மற்றும் நீங்கள் வெறும் கற்றுக்கொண்டு உள்ளீர்கள் ஏதாவது முக்கியமான. பிழை isolation-ல் persist என்றால், நீங்கள் இப்போது ஒரு சிறிய, shareable, testable case வைத்துள்ளீர்கள், மற்றும் நீங்கள் உண்மையான fix-க்கு மிக நெருக்கமாக உள்ளீர்கள்.

உங்கள் assumptions-ஐ memory-க்கு எதிரான reality-க்கு சரிபார்க்கவும்

Debug நேரத்தின் ஒரு பெரிய பகுதி unquestioned assumptions-ஏ செல்லுகிறது: