𝗖𝗼𝗱𝗲 𝗗𝘂𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻 (குறியீடு நகலாக்கம்) 𝘃𝘀. 𝗪𝗿𝗼𝗻𝗴 𝗔𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻𝘀 (தவறான சுருக்கங்கள்)
மென்பொருள் உருவாக்குநர்கள் (Developers) பெரும்பாலும் ஒரு தேர்வை எடுப்பதில் தடுமாறுகிறார்கள்.
நீங்கள் 'Don't Repeat Yourself' (DRY) கொள்கையைப் பின்பற்ற வேண்டுமா அல்லது சில குறியீடு நகல்களை (code duplication) அனுமதிக்க வேண்டுமா என்ற தேர்வுக்கு இடையில் இருக்கிறீர்கள்.
மென்பொருள் வடிவமைப்பில் DRY என்பது ஒரு முக்கிய விதியாகும். ஆனால் அதைத் தீவிரமாகப் பின்பற்றுவது ஒரு புதிய சிக்கலை உருவாக்குகிறது. நீங்கள் ஒரு தவறான சுருக்கத்தை (wrong abstraction) உருவாக்கிவிடுகிறீர்கள்.
நகல் குறியீட்டை விட ஒரு தவறான சுருக்கமே அதிக இழப்பை ஏற்படுத்தும்.
நாம் நேர்த்தியான குறியீட்டை (elegant code) எழுத விரும்புகிறோம். மீண்டும் பயன்படுத்தக்கூடிய தர்க்கத்தை (reusable logic) உருவாக்க விரும்புகிறோம். ஒரு இடத்தில் பிழையைச் சரிசெய்தால், அது எல்லா இடங்களிலும் சரிசெய்யப்பட வேண்டும் என்று விரும்புகிறோம். இந்த இலக்கு சரியானது என்று தோன்றுகிறது.
ஆனால் முன்கூட்டியே செய்யப்படும் சுருக்கங்கள் (premature abstraction) திட்டத்தின் வேகத்தைக் குறைத்துவிடும். இது உங்கள் குறியீட்டைப் பராமரிக்கும் எளிமையைச் சிதைத்துவிடும்.
நீங்கள் மிக விரைவாகச் சுருக்கங்களை (abstract) செய்யும்போது, பின்வரும் சிக்கல்களைச் சந்திக்க நேரிடும்:
- அதிகரித்த சிக்கல்தன்மை (Increased complexity). மோசமான சுருக்கங்கள் குழப்பத்தின் அடுக்குகளைச் சேர்க்கின்றன.
- நெகிழ்வற்ற குறியீடு (Rigid code). மற்ற பகுதிகளைப் பாதிக்காமல் ஒரு பகுதியை மட்டும் மாற்றுவது கடினமாகிவிடும்.
- மறைக்கப்பட்ட தர்க்கம் (Hidden logic). குறியீட்டை எழுதுவதை விட, அதைத் தேடிப் பிடிப்பதிலேயே (tracing) அதிக நேரத்தைச் செலவிடுவீர்கள்.
சில நேரங்களில், நகலாக்கம் (duplication) என்பதே நடைமுறைச் சாத்தியமான தேர்வாக இருக்கும். இது உங்கள் குறியீட்டை எளிமையாகவும் தெளிவாகவும் வைத்திருக்கும். உங்கள் அமைப்பின் பகுதிகளைத் தனித்தனியாக மாற்ற இது அனுமதிக்கிறது.
உங்களுக்கு முழுமையாகப் புரியாத ஒரு பிரச்சனைக்கு பொதுவான தீர்வை (generic solution) உருவாக்க வேண்டாம். அந்தப் படிவம் (pattern) தெளிவாகத் தெரியும் வரை காத்திருங்கள்.