பழைய குறியீடு (Legacy Code) காலப்போக்கில் மோசமடைகிறது

பழைய குறியீடு (Legacy code) மதுவைப் போல காலப்போக்கில் சிறப்பாவதில்லை. நீங்கள் அதை அலட்சியப்படுத்தும் ஒவ்வொரு நாளும் அது மோசமடைகிறது.

கடந்த வாரம், 20 நிமிடங்களில் தீர்க்கப்பட வேண்டிய ஒரு சிக்கலைத் தீர்க்க (debugging) நான் மூன்று மணிநேரம் செலவிட்டேன். அதற்குப் காரணமான 2019-ஆம் ஆண்டின் ஒரு validation module தான். அது வேலை செய்ததால் மக்கள் அதை அப்படியே விட்டுவிட்டார்கள். ஆனால் அது வேலை செய்யவில்லை. 2020-ஆம் ஆண்டிலிருந்து இருந்த ஒரு "TODO: refactor this" என்ற கருத்தைக் (comment) கண்டேன்.

பலர் legacy code-ஐத் தவிர்க்கக்கூடிய ஒரு கடனாகக் கருதுகிறார்கள். நேரம் கிடைக்கும்போது அதைச் சரிசெய்துவிடலாம் என்று நினைக்கிறார்கள். Legacy code பூஞ்சையைப் போன்றது. அது பரவும். அது தன்னைச் சுற்றியுள்ள அனைத்தையும் பாதிக்கும். நீங்கள் எவ்வளவு காலம் தாமதப்படுத்துகிறீர்களோ, அவ்வளவு அதிகமாக அதைச் சரிசெய்வதற்கான செலவு அதிகரிக்கும்.

இந்தச் சுழற்சி கணிக்கக்கூடியது:

• நீங்கள் குழப்பமான ஆனால் வேலை செய்யும் ஒரு அம்சத்தைப் (feature) பெறுகிறீர்கள்.
• அதைச் செயல்பட வைக்க இன்னும் ஒரு "if" கூற்றைச் (statement) சேர்க்கிறீர்கள்.
• ஆறு மாதங்களுக்குப் பிறகு, வேறொருவர் இதையே செய்கிறார்.
• ஒரு வருடம் கழித்து, அந்த கோப்பில் (file) 800 வரிகள் இருக்கும், ஆனால் ஒரு சோதனை (test) கூட இருக்காது.

இந்த மறைமுகச் செலவு மூன்று வழிகளில் உங்களைத் தாக்கும்:

• வேகம் குறைகிறது. குறியீட்டை எழுதுவதை விட, அதன் சூழலைப் (context) புரிந்துகொள்வதற்கே அதிக நேரம் செலவிடுகிறீர்கள்.
• பிழைகள் (Bugs) அதிகரிக்கின்றன. தர்க்கம் (logic) சிக்கலாக இருப்பதால், ஒரு பிழையைச் சரிசெய்யும்போது மற்றொன்று உடைந்து போகிறது.
• புதிய பணியாளர்களைப் பணியில் இணைத்தல் (Onboarding) தோல்வியடைகிறது. ஒரே தர்க்கம் ஏன் ஏழு வெவ்வேறு இடங்களில் உள்ளது என்பதைப் புரிந்துகொள்ள புதிய டெவலப்பர்கள் சிரமப்படுகிறார்கள்.

இந்த எச்சரிக்கை அறிகுறிகளைக் கவனியுங்கள்:

• "HACK: do not touch this" போன்ற பயனற்ற கருத்துகள்.
• வெவ்வேறு கோப்புகளில் ஒரே மாதிரியான வணிகத் தர்க்கங்கள் (business logic) இருப்பது.
• சேவைகள் ஒன்றையொன்று சார்ந்திருக்கும் சுழற்சி சார்ந்த சார்புகள் (Circular dependencies).

அனைத்தையும் மீண்டும் எழுதாதீர்கள். முழுமையான மறுபதிவுகள் (Full rewrites) 80% நேரங்களில் தோல்வியடைகின்றன. அதற்குப் பதிலாக, characterization tests உடன் படிப்படியான மறுசீரமைப்பைப் (incremental refactoring) பயன்படுத்துங்கள்.

இந்தச் செயல்முறையைப் பின்பற்றுங்கள்:

• விசித்திரமான பகுதிகள் உட்பட, தற்போதைய செயல்பாட்டைச் சோதனைகள் (tests) மூலம் பதிவு செய்யுங்கள்.
• அந்தச் செயல்பாட்டை மாற்றாமல் குறியீட்டை மறுசீரமைக்கவும் (Refactor).
• குறியீடு வாசிக்கத் தகுந்ததாக மாறும் வரை இதைத் திரும்பத் திரும்பச் செய்யுங்கள்.
• உண்மையான சோதனைகள் கிடைத்த பின்னரே செயல்பாட்டை மாற்றவும்.

பின்பற்ற வேண்டிய விதிகள்:

• சோதனைகள் இல்லாமல் ஒருபோதும் மறுசீரமைக்காதீர்கள்.
• குறியீடு செயல்படும் விதத்தை மாற்றும் மேம்பாடுகளைத் தவிர்க்கவும். ஒரு பிழை, ஒரு வாடிக்கையாளர் நம்பியிருக்கும் ஒரு அம்சமாக (feature) இருக்கலாம்.
• அமைதியாக இருக்கும் குறியீட்டைத் தொடாதீர்கள். ஒரு மாட்யூல் (module) மூன்று ஆண்டுகளாக மாறாமல் இருந்து, எந்தப் பிரச்சினையையும் ஏற்படுத்தவில்லை என்றால், அதைத் தொடாதீர்கள்.

நீங்கள் அடிக்கடி கையாளும் குறியீட்டில் உங்கள் ஆற்றலைச் செலவிடுங்கள்.

Source: https://dev.to/taina_costa_f/legacy-code-nao-envelhece-como-vinho-quanto-mais-espera-pior-fica-132h