കോഡ് ഡ്യൂപ്ലിക്കേഷനും തെറ്റായ അബ്സ്ട്രാക്ഷനുകളും തമ്മിലുള്ള വ്യത്യാസം
ഡെവലപ്പർമാർ പലപ്പോഴും ഒരു തിരഞ്ഞെടുപ്പിൽ ബുദ്ധിമുട്ടാറുണ്ട്.
'Don't Repeat Yourself' എന്ന തത്വവും അല്ലെങ്കിൽ അല്പം കോഡ് ഡ്യൂപ്ലിക്കേഷൻ അനുവദിക്കുന്നതും തമ്മിൽ നിങ്ങൾ തിരഞ്ഞെടുക്കേണ്ടി വരും.
DRY എന്നത് സോഫ്റ്റ്വെയർ ഡിസൈനിലെ ഒരു പ്രധാന നിയമമാണ്. എന്നാൽ ഇത് അമിതമായി പിന്തുടരുന്നത് പുതിയൊരു പ്രശ്നത്തിന് കാരണമാകും. നിങ്ങൾ ഒരു തെറ്റായ അബ്സ്ട്രാക്ഷൻ (wrong abstraction) നിർമ്മിക്കുന്നു.
ഡ്യൂപ്ലിക്കേറ്റ് കോഡിനേക്കാൾ കൂടുതൽ ചിലവ് വരുത്തുന്നത് ഒരു തെറ്റായ അബ്സ്ട്രാക്ഷനാണ്.
നമുക്ക് മികച്ച രീതിയിലുള്ള കോഡ് എഴുതണം. വീണ്ടും ഉപയോഗിക്കാൻ കഴിയുന്ന ലോജിക് നിർമ്മിക്കണം. ഒരു സ്ഥലത്ത് ഒരു ബഗ് പരിഹരിച്ചാൽ അത് എല്ലായിടത്തും പരിഹരിക്കപ്പെടണം എന്ന് നമ്മൾ ആഗ്രഹിക്കുന്നു. ഈ ലക്ഷ്യം ശരിയാണെന്ന് നമുക്ക് തോന്നാം.
എന്നാൽ അകാലത്തിലുള്ള അബ്സ്ട്രാക്ഷൻ (premature abstraction) പ്രോജക്റ്റിന്റെ വേഗത കുറയ്ക്കുന്നു. ഇത് കോഡ് മെയിന്റയിൻ ചെയ്യുന്നത് പ്രയാസകരമാക്കുന്നു.
നിങ്ങൾ വളരെ നേരത്തെ തന്നെ അബ്സ്ട്രാക്ഷൻ നടപ്പിലാക്കിയാൽ താഴെ പറയുന്ന പ്രശ്നങ്ങൾ നേരിടേണ്ടി വരും:
- സങ്കീർണ്ണത വർദ്ധിക്കുന്നു. മോശം അബ്സ്ട്രാക്ഷനുകൾ ആശയക്കുഴപ്പങ്ങൾ ഉണ്ടാക്കുന്നു.
- മാറ്റങ്ങൾ വരുത്താൻ പ്രയാസമുള്ള കോഡ് (Rigid code). മറ്റുള്ളവയെ ബാധിക്കാതെ ഒരു ഭാഗം മാത്രം മാറ്റുന്നത് പ്രയാസകരമായിത്തീരുന്നു.
- മറഞ്ഞിരിക്കുന്ന ലോജിക്. കോഡ് എഴുതുന്നതിനേക്കാൾ കൂടുതൽ സമയം അത് പരിശോധിക്കാനായി (tracing) നിങ്ങൾ ചെലവഴിക്കേണ്ടി വരുന്നു.
ചിലപ്പോൾ, ഡ്യൂപ്ലിക്കേഷൻ എന്നത് പ്രായോഗികമായ ഒരു തീരുമാനമായിരിക്കും. ഇത് നിങ്ങളുടെ കോഡിനെ ലളിതവും വ്യക്തവുമാക്കുന്നു. സിസ്റ്റത്തിന്റെ ഭാഗങ്ങൾ സ്വതന്ത്രമായി മാറ്റാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.
നിങ്ങൾക്ക് പൂർണ്ണമായി മനസ്സിലാകാത്ത ഒരു പ്രശ്നത്തിന് വേണ്ടി പൊതുവായ ഒരു പരിഹാരം (generic solution) നിർമ്മിക്കരുത്. ഒരു പാറ്റേൺ വ്യക്തമാകുന്നതുവരെ കാത്തിരിക്കുക.