தவறான Abstractions-ஐ விட Code Duplication மலிவானது
பெரும்பாலான டெவலப்பர்கள் ஆரம்பத்திலேயே DRY கொள்கையைக் கற்றுக்கொள்கிறார்கள். அதாவது, உங்களை நீங்களே மீண்டும் மீண்டும் செய்யாதீர்கள் (Do Not Repeat Yourself).
இந்த விதி அர்த்தமுள்ளதே. இது பிழைகளைத் தடுக்கிறது மற்றும் நேரத்தைச் சேமிக்கிறது.
ஆனால் பல டெவலப்பர்கள் இந்த விதியை மிகக் கடுமையாகப் பின்பற்றுகிறார்கள். அவர்கள் அனைத்தையும் ஒரே function அல்லது class-க்குள் இணைக்க முயற்சிக்கிறார்கள். இது over-engineering-க்கு வழிவகுக்கிறது.
இரண்டு வெவ்வேறு தர்க்கங்களை (logic) ஒரே abstraction-க்குள் நீங்கள் கட்டாயப்படுத்தும்போது, சிக்கல்களை உருவாக்குகிறீர்கள். நீங்கள் சிக்கலான தன்மையைச் சேர்க்கிறீர்கள். குறியீட்டைப் படிப்பதை கடினமாக்குகிறீர்கள்.
ஒரு தவறான abstraction, சிறிய அளவிலான duplication-ஐ விட அதிகச் செலவை ஏற்படுத்தும்.
நீங்கள் குறியீட்டை நகலெடுத்தால் (duplicate), அந்த logic எங்குள்ளது என்பதைத் துல்லியமாகத் தெரிந்து கொள்ளலாம். ஒரு பகுதியை மாற்ற வேண்டியிருந்தால், அங்கேயே மாற்றிக்கொள்ளலாம்.
நீங்கள் ஒரு மோசமான abstraction-ஐப் பயன்படுத்தினால், அதனுடன் இணைக்கப்பட்ட அனைத்தையும் மாற்ற வேண்டியிருக்கும். உங்கள் தற்போதைய பணிக்கும் தொடர்பில்லாத அம்சங்களை (features) உடைத்துவிடும் அபாயமும் உள்ளது.
பாதுகாப்பாக இருக்க இந்த விதிகளைப் பின்பற்றுங்கள்:
- தற்போதைய பணிக்குத் தேவையான குறியீட்டை மட்டும் எழுதுங்கள்.
- ஒரு abstraction-ஐ உருவாக்குவதற்கு முன், ஒரு pattern மூன்று முறை தோன்றும் வரை காத்திருங்கள்.
- சில வரிகளைக் குறைப்பதை விட, குறியீட்டின் வாசிப்புத்திறனுக்கு (readability) முன்னுரிமை கொடுங்கள்.
- சில நேரங்களில் duplication ஆரோக்கியமானது என்பதை ஏற்றுக்கொள்ளுங்கள்.
ஒவ்வொரு வரியையும் மிகச்சரியாக மாற்ற முயற்சிப்பதை நிறுத்துங்கள். உங்கள் குறியீட்டை எளிதாக மாற்றக்கூடியதாக மாற்றுவதில் கவனம் செலுத்துங்கள்.