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

லெகசி கோட் காலப்போக்கில் மேம்படாது. அது மோசமடையும்.

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

பலர் லெகசி கோடை ஒரு விருப்பத்தேர்வு கடனாகக் கருதுகிறார்கள். நேரம் கிடைக்கும்போது அதைச் சரிசெய்துவிடலாம் என்று நினைக்கிறார்கள். ஆனால் லெகசி கோட் என்பது பூஞ்சையைப் போன்றது. அது பரவும். அது உங்கள் சிஸ்டத்தின் மற்ற பகுதிகளைவும் பாதிக்கும். நீங்கள் அதை எவ்வளவு காலம் புறக்கணிக்கிறீர்களோ, அவ்வளவு அதிகமாக அதைச் சரிசெய்ய செலவாகும்.

இது ஒரு மோசமான சுழற்சியை உருவாக்குகிறது:

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

இந்த "வேலை செய்யும்" கோடில் மறைமுகமான செலவுகள் உள்ளன:

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

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

• பயனற்ற அல்லது தவறான தகவல்களைக் கூறும் கமெண்ட்கள்.
• வெவ்வேறு கோப்புகளில் மீண்டும் மீண்டும் வரும் business logic.
• Circular dependencies மற்றும் அதிகப்படியான coupling.

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

Characterization tests-உடன் கூடிய படிப்படியான refactoring-ஐப் பயன்படுத்தவும்:

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

சிக்கல்களைத் தவிர்க்க இந்த விதிகளைப் பின்பற்றுங்கள்:

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

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

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