ഒറ്റത്തവണ ഉപയോഗിക്കാവുന്ന കോഡ് (Disposable Code) എന്നത് ഒരു കള്ളമാണ്

AI യുഗത്തിൽ കോഡിന്റെ ആയുസ്സ് അവസാനിച്ചു എന്ന് ആളുകൾ പറയുന്നു. AI പത്ത് മടങ്ങ് വേഗത്തിൽ കോഡ് വീണ്ടും എഴുതുമെന്ന് അവർ അവകാശപ്പെടുന്നു. പിന്നീട് എപ്പോൾ വേണമെങ്കിലും പുതിയ കോഡ് നിർമ്മിക്കാമെങ്കിൽ എന്തിനാണ് ദീർഘകാലം നിലനിൽക്കുന്ന കോഡ് എഴുതുന്നത് എന്ന് അവർ ചോദിക്കുന്നു.

ഈ ചിന്താഗതി ഒരു മിഥ്യയാണ്. സോഫ്റ്റ്‌വെയറുകൾ പരിപാലിക്കാത്ത (maintain ചെയ്യാത്ത) ആളുകളിൽ നിന്നാണ് ഇത് പ്രധാനമായും വരുന്നത്.

ഈ വാദം കേൾക്കാൻ നല്ലതാണ്. നിങ്ങൾക്ക് കുഴഞ്ഞുമറിഞ്ഞ ഒരു കോഡ് ബേസ് (codebase) ലഭിക്കുന്നു. അത് ഉപേക്ഷിക്കാൻ നിങ്ങൾ തീരുമാനിക്കുകയും കൂടുതൽ വൃത്തിയുള്ള ഒന്ന് വേണമെന്ന് AI-യോട് ആവശ്യപ്പെടുകയും ചെയ്യുന്നു. ഇത് പുരോഗതിയാണെന്ന് തോന്നാം. എന്നാൽ യഥാർത്ഥത്തിൽ, ഇതൊരു എഞ്ചിനീയറിംഗ് പരാജയമാണ്.

നിലവിലുള്ള ഒരു കോഡ് ബേസിനെക്കുറിച്ച് ആളുകൾ മറന്നുപോകുന്ന കാര്യം ഇതാണ്: അത് വെറും ലോജിക് മാത്രമല്ല. നിങ്ങൾ പരിഹരിച്ച ഓരോ പിശകിന്റെയും രേഖയാണത്.

412-ാം വരിയിലെ ആ വിചിത്രമായ if സ്റ്റേറ്റ്‌മെന്റ് ഒരു കാരണത്താലാണ് അവിടെയുള്ളത്. ടൈം സോൺ മാറുന്ന സമയത്ത് ഒരു പേയ്‌മെന്റ് പ്രൊവൈഡറിൽ നിന്നുള്ള പ്രത്യേക പിശക് കൈകാര്യം ചെയ്യാൻ വേണ്ടിയാണത്. ആ ലോജിക് ഒരു ടിക്കറ്റിലും (ticket) രേഖപ്പെടുത്തിയിട്ടുണ്ടാകില്ല; അത് കോഡിനുള്ളിൽ ജീവിക്കുന്നു.

ഓരോ തവണ കോഡ് വീണ്ടും എഴുതുന്നതും ഒരുതരം 'മെമ്മറി ലോസ്' (memory loss) ഉണ്ടാക്കുന്നു. അറിവില്ലാതെ കൈകാര്യം ചെയ്ത കാര്യങ്ങളും (implicit knowledge) അപൂർവ്വ സാഹചര്യങ്ങൾക്കുള്ള (edge-case) പരിഹാരങ്ങളും നിങ്ങൾക്ക് നഷ്ടപ്പെടുന്നു. AI-ക്ക് വേഗത്തിൽ കോഡ് എഴുതാൻ കഴിയും, പക്ഷേ നിങ്ങളുടെ ടീം മുൻപ് എടുത്ത തീരുമാനങ്ങൾ അതിന് പുനഃസൃഷ്ടിക്കാൻ കഴിയില്ല. ഒരു സിസ്റ്റം പരാജയപ്പെട്ടതിന് ശേഷം നിങ്ങളുടെ 'റീട്രൈ ലോജിക്' (retry logic) രൂപപ്പെടുത്താൻ നിങ്ങൾ ചിലവിട്ട മാസങ്ങളുടെ അധ്വാനം അതിന് പകരം വെക്കാൻ കഴിയില്ല.

നിർമ്മാണത്തിന്റെ വേഗത എന്നത് മനസ്സിലാക്കാനുള്ള വേഗതയല്ല. മിനിറ്റുകൾക്കുള്ളിൽ നിങ്ങൾക്ക് ആയിരം വരി കോഡ് നിർമ്മിക്കാം. എന്നാൽ ആയിരം വരി കോഡ് വായിച്ചു മനസ്സിലാക്കാൻ ഇപ്പോഴും മണിക്കൂറുകൾ എടുക്കും. AI ഈ അനുപാതം മാറ്റുന്നില്ല.

ടൈപ്പ് ചെയ്യുക എന്നതൊരിക്കലും പ്രയാസകരമായ കാര്യമല്ലായിരുന്നു. എന്താണ് ടൈപ്പ് ചെയ്യേണ്ടതെന്ന് കണ്ടെത്തുക എന്നതായിരുന്നു പ്രയാസകരമായ കാര്യം.

കോഡിനെ 'ഒറ്റത്തവണ ഉപയോഗിക്കാവുന്നത്' (disposable) ആയി കാണുന്നു എന്നതിനർത്ഥം, നിങ്ങളുടെ ഉപയോക്താക്കളെയും നിങ്ങളുടെ സർവീസിന്റെ ലഭ്യതയെയും (uptime) നിങ്ങൾ അങ്ങനെ തന്നെ കാണുന്നു എന്നാണ്. ഓരോ തവണ കോഡ് മാറ്റുന്നതും ഒരു റിസ്ക് ഘട്ടം (risk window) സൃഷ്ടിക്കുന്നു. ഓരോ റിസ്ക് ഘട്ടവും പിഴവുകളിലേക്ക് (regressions) നയിക്കുന്നു. ഓരോ പിഴവും നിങ്ങളെ വിശ്വസിക്കുന്ന ഒരു ഉപയോക്താവിനെ വേദനിപ്പിക്കുന്നു.

നിങ്ങൾ ഒരു വീക്കെൻഡ് പ്രോജക്റ്റ് (weekend project) ആണ് നിർമ്മിക്കുന്നതെങ്കിൽ, എപ്പോൾ വേണമെങ്കിലും അത് മാറ്റിയെഴുതാം. ആരും ശ്രദ്ധിക്കില്ല.

എന്നാൽ ആളുകൾ വിശ്വസിച്ചു ഉപയോഗിക്കുന്ന ഒരു ഉൽപ്പന്നമാണ് നിങ്ങൾ കൈകാര്യം ചെയ്യുന്നതെങ്കിൽ, നിങ്ങൾക്ക് ഈ ആഡംബരം അനുവദനീയമല്ല. ഒരു അവധിദിവസം പുലർച്ചെ 2 മണിക്ക് കാര്യങ്ങൾ തകരാറിലാക്കാൻ നിങ്ങൾക്ക് കഴിയില്ല.

കോഡ് വീണ്ടും എഴുതുന്നത് സാങ്കേതിക കടങ്ങൾ (tech debt) പരിഹരിക്കുന്നില്ല. അത് ആ കടം കണ്ടെത്താനുള്ള സമയം വീണ്ടും റീസെറ്റ് ചെയ്യുക മാത്രമാണ് ചെയ്യുന്നത്.

പ്രോജക്റ്റുകൾ തുടങ്ങുക മാത്രം ചെയ്യുകയും അവ പരിപാലിക്കാതിരിക്കുകയും ചെയ്യുന്നവർക്ക് വേണ്ടിയുള്ളതാണ് ഈ വാദം. AI എല്ലാത്തിനെയും പകരം വെക്കാവുന്നതാക്കുന്നു എന്ന ആശയം വിൽക്കുന്നവർക്ക് ഇത് ഗുണകരമാണ്. എന്നാൽ കോഡ് മാറ്റിയെഴുതുന്നത് പരാജയപ്പെടുമ്പോൾ വിളിക്കപ്പെടുന്ന (paged) എഞ്ചിനീയർക്കോ ഉപയോക്താവിനോ ഇത് ഗുണകരമല്ല.

സോഫ്റ്റ്‌വെയറിന്റെ യാഥാർത്ഥ്യം അതിന്റെ പരിപാലനമാണ് (maintenance). നിങ്ങൾ ഒരിക്കലും ഒരു സേവനം നിലനിർത്തേണ്ടി വരുന്നില്ലെങ്കിൽ മാത്രം പ്രായോഗികമാകുന്ന ഒരു തത്വമാണ് 'ഡിസ്പോസബിൾ കോഡ്'.

മികച്ചതും കൂടുതൽ കാലം നിലനിൽക്കുന്നതുമായ കോഡ് എഴുതാൻ AI-യെ സഹായിയായി ഉപയോഗിക്കുക. എല്ലാം ആദ്യം മുതൽ വീണ്ടും നിർമ്മിക്കാനുള്ള ഒരു ഒഴികഴിവായി അതിനെ ഉപയോഗിക്കരുത്.

ഈടുനിൽക്കുന്ന കോഡ് (durability) ആണ് ചടുലതയെ (agility) സുസ്ഥിരമാക്കുന്നത്.

നിങ്ങളുടെ സിസ്റ്റത്തിലെ ഏറ്റവും പഴക്കമുള്ള കോഡ് ഏതാണ്? അത് നീക്കം ചെയ്താൽ നിങ്ങൾക്ക് എന്ത് നഷ്ടപ്പെടും?

സ്രോതസ്സ്: https://dev.to/adioof/disposable-code-is-a-psyop-by-people-who-dont-maintain-anything-33kg

ഓപ്ഷണൽ ലേണിംഗ് കമ്മ്യൂണിറ്റി: https://t.me/GyaanSetuAi