தவறான Abstractions விட Code Duplication மலிவானது
டெவலப்பர்கள் DRY கொள்கையை விரும்புகிறார்கள்.
நீங்கள் ஒரே விஷயத்தை மீண்டும் மீண்டும் செய்வதைத் தவிர்க்க விரும்புகிறீர்கள். நேர்த்தியான மற்றும் மீண்டும் பயன்படுத்தக்கூடிய (reusable) குறியீட்டை நீங்கள் விரும்புகிறீர்கள்.
ஆனால் இந்த இலக்கு பெரும்பாலும் ஒரு பொறியிலேயே முடிகிறது: அதுதான் முன்கூட்டியே செய்யப்படும் Abstraction (premature abstraction).
குறியீட்டைத் திரும்பத் திரும்ப எழுதுவது தவறானது என்று தோன்றலாம். இருப்பினும், ஒரு மோசமான Abstraction-ஐ விட, குறியீட்டை நகலெடுப்பது (duplication) பெரும்பாலும் மலிவானது.
நாம் சரியான மாடுலர் அமைப்புகளை (modular systems) உருவாக்க முயற்சிக்கிறோம். சிக்கல்களைக் கையாள நாம் வடிவங்களைத் (patterns) தேடி, அதிலிருந்து தர்க்கத்தைப் (logic) பிரித்தெடுக்கிறோம்.
சிறப்பாக வடிவமைக்கப்பட்ட Abstractions மென்பொருள் விரிவாக்கத்திற்கு (scale) உதவுகின்றன.
ஆனால் பல Abstractions மிக விரைவாகவே உருவாக்கப்படுகின்றன. நீங்கள் சிக்கலை முழுமையாகப் புரிந்துகொள்ளவில்லை என்றால், உங்கள் Abstraction ஒரு சுமையாக மாறிவிடும்.
தவறான Abstraction பல சிக்கல்களை ஏற்படுத்துகிறது:
- Over-engineering: எளிய சிக்கல்களுக்கு நீங்கள் சிக்கலான தீர்வுகளை உருவாக்குகிறீர்கள்.
- Rigidity: உங்கள் குறியீட்டை மாற்றுவது கடினமாகிவிடும், ஏனெனில் அது நடக்காத ஒரு எதிர்காலத்தைக் கணிக்க முயல்கிறது.
- Obscured Intent: பிசினஸ் லாஜிக் (Business logic) பொதுவான இன்டர்ஃபேஸ்களின் (generic interfaces) அடுக்குகளுக்கு அடியில் மறைந்துவிடுகிறது. இது டீபக்கிங் (debugging) செய்வதைக் கடினமாக்குகிறது.
- Tight Coupling: உங்கள் அமைப்பின் பகுதிகள் அந்த Abstraction-உடன் பிணைக்கப்பட்டு விடுகின்றன.
இதன் விலை அதிகம். பயனர் சிக்கல்களைத் தீர்ப்பதற்குப் பதிலாக, உங்கள் சொந்த கட்டமைப்போடு (architecture) போராடுவதிலேயே நேரத்தைச் செலவிடுகிறீர்கள். இது உங்கள் குழுவின் வேகத்தைக் குறைப்பதோடு, ரீஃபாக்டரிங் (refactoring) செய்வதையும் கடினமாக்குகிறது.
எல்லாவற்றையும் காப்பி செய்து பேஸ்ட் செய்யச் சொல்லவில்லை. நான் ஒரு நடைமுறை அணுகுமுறையை (pragmatic approach) பரிந்துரைக்கிறேன்.
கட்டுப்படுத்தப்பட்ட நகலெடுப்பை (controlled duplication) ஒரு கருவியாகப் பயன்படுத்துங்கள். தேவைகள் வேகமாக மாறும் இடங்களிலோ அல்லது நிச்சயமற்ற சூழல் இருக்கும் இடங்களிலோ இதைப் பயன்படுத்துங்கள்.
Abstraction-ஐ உருவாக்குவதற்கு முன், அந்தப் வடிவத்தை (pattern) நீங்கள் தெளிவாகப் பார்க்கும் வரை காத்திருங்கள்.