PHP-യിൽ നിന്ന് Go-യിലേക്ക്: എന്റെ ചിന്താഗതി മാറ്റാൻ ഏറ്റവും കൂടുതൽ സമയം എടുത്തത് എന്താണ്?
ഏഴ് വർഷം ഞാൻ PHP ഉപയോഗിച്ചു. അതിൽ അഞ്ച് വർഷം ഞാൻ Laravel ഉപയോഗിച്ചു. ഒരു Laravel monolith-ൽ നിന്ന് microservices-ലേക്ക് മാറുന്ന പ്രക്രിയ നയിക്കാൻ ഞാൻ Go ഉപയോഗിക്കാൻ തുടങ്ങിയപ്പോൾ, എന്റെ കയ്യിൽ ഒരു ട്യൂട്ടോറിയൽ ഉണ്ടായിരുന്നില്ല. പകരം, പത്ത് വർഷത്തെ PHP ശീലങ്ങളായിരുന്നു ഉണ്ടായിരുന്നത്.
സിന്റാക്സ് (syntax) പഠിക്കുന്നത് എളുപ്പമായിരുന്നു. ഒരു ഉച്ചനേരത്തിനുള്ളിൽ നിങ്ങൾക്ക് Go വായിച്ചു തുടങ്ങാം. എന്നാൽ കോഡിനെക്കുറിച്ചുള്ള എന്റെ പഴയ ചിന്താഗതികൾ മാറ്റിവെക്കുക എന്നതായിരുന്നു പ്രയാസകരമായ കാര്യം.
മാസങ്ങൾ എടുത്തു മനസ്സിലാക്കാൻ എനിക്ക് സാധിച്ച ആ മാനസിക മാറ്റങ്ങൾ ഇവയാണ്:
Error Handling In PHP, ഞാൻ try/catch ആണ് ഉപയോഗിച്ചിരുന്നത്. പലപ്പോഴും എററുകൾ ഒരു ഗ്ലോബൽ ഹാൻഡ്ലറിലേക്ക് (global handler) അദൃശ്യമായി പോകുമായിരുന്നു. എന്നാൽ Go-യിൽ, എററുകൾ വെറും വാല്യൂസ് (values) ആണ്. ഒരു ഫങ്ക്ഷൻ അതിന്റെ അവസാന വാല്യൂ ആയി ഒരു എറർ റിട്ടേൺ ചെയ്യുന്നു. നിങ്ങൾ അത് അവിടെത്തന്നെ കൈകാര്യം ചെയ്യണം. തുടക്കത്തിൽ ഇത് അനാവശ്യമായ ജോലിയായി എനിക്ക് തോന്നി. എന്നാൽ പിന്നീട് ഞാൻ മനസ്സിലാക്കി, ഇത് പരാജയങ്ങളെ കൂടുതൽ വ്യക്തമാക്കുന്നു എന്നാണ്. ഒരു സർവീസ് പരാജയപ്പെടുമ്പോൾ, ആ എറർ മെസ്സേജ് ഒരു വഴികാട്ടിയായി പ്രവർത്തിക്കുന്നു. വലിയൊരു സ്റ്റാക്ക് ട്രേസ് (stack trace) ഇല്ലാതെ തന്നെ പരാജയം എവിടെയാണ് സംഭവിച്ചതെന്ന് അത് കൃത്യമായി പറഞ്ഞുതരുന്നു.
Memory and State PHP ഉപയോഗിക്കുന്നത് ഒരു shared-nothing മോഡലാണ്. ഓരോ റിക്വസ്റ്റും പുതിയൊരു തുടക്കമാണ്. റിക്വസ്റ്റ് കഴിയുന്നതോടെ പ്രോസസ്സ് അവസാനിക്കുന്നതുകൊണ്ട് മെമ്മറി ലീക്കുകൾ (memory leaks) വലിയ പ്രശ്നമാകാറില്ല. എന്നാൽ Go വ്യത്യസ്തമാണ്. ആയിരക്കണക്കിന് റിക്വസ്റ്റുകൾക്കായി പ്രോസസ്സ് സജീവമായി തുടരുന്നു. ഇതിനർത്ഥം ഒരു പാക്കേജ് ലെവൽ വേരിയബിൾ (package-level variable) എല്ലാ റിക്വസ്റ്റുകളിലും പങ്കിടപ്പെടുന്നു എന്നാണ്. ഒരേ സമയം രണ്ട് റിക്വസ്റ്റുകൾ ഒരു മാപ്പിൽ (map) എഴുതാൻ ശ്രമിച്ചാൽ പ്രോഗ്രാം മുഴുവനായി ക്രാഷ് ചെയ്യും. Go-യിൽ, കോൺകറൻസി (concurrency) നിങ്ങൾ തന്നെ നിയന്ത്രിക്കണം. സുരക്ഷിതമായിരിക്കാൻ race detector പോലുള്ള ടൂളുകൾ നിങ്ങൾ ഉപയോഗിക്കേണ്ടതുണ്ട്.
The Role of Context PHP-യിൽ, ഒരു റിക്വസ്റ്റ് ആണ് പരിധി (boundary). റിക്വസ്റ്റ് അവസാനിക്കുമ്പോൾ എല്ലാം നിൽക്കുന്നു. എന്നാൽ Go-യിൽ ഒന്നും തനിയെ നിൽക്കില്ല. ഒരു ക്ലയന്റ് ഡിസ്കണക്റ്റ് ആയാൽ പോലും, നിങ്ങളുടെ goroutines പ്രവർത്തിച്ചുകൊണ്ടിരിക്കുകയും റിസോഴ്സുകൾ പാഴാക്കുകയും ചെയ്തേക്കാം. ക്യാൻസലേഷൻ സിഗ്നലുകൾ (cancellation signals) കോഡിലൂടെ കൈമാറാൻ നിങ്ങൾ context.Context ഉപയോഗിക്കണം. കനത്ത ലോഡിനിടയിലും നിങ്ങളുടെ സർവീസിനെ ആരോഗ്യത്തോടെ നിലനിർത്തുന്ന നട്ടെല്ലാണ് ഇത്.
Composition Over Inheritance ബേസ് ക്ലാസുകൾ (base classes) എക്സ്റ്റൻഡ് ചെയ്യുന്നതിനെയാണ് Laravel പ്രധാനമായും ആശ്രയിക്കുന്നത്. ഇൻഹെറിറ്റൻസ് (inheritance) വഴി ഫീച്ചറുകൾ ചേർക്കാൻ സാധിക്കുന്നു. എന്നാൽ Go-യിൽ ക്ലാസ് ഇൻഹെറിറ്റൻസ് ഇല്ല. പകരം ഇംപ്ലിസിറ്റ് ആയി (implicitly) പ്രവർത്തിക്കുന്ന ഇന്റർഫേസുകളാണ് (interfaces) ഉപയോഗിക്കുന്നത്. നിങ്ങൾക്ക് എന്തിനാവശ്യമോ അത് ഉപയോഗിക്കുന്ന ഇടത്ത് തന്നെ നിർവചിക്കാം. ഇത് കോഡ് ടെസ്റ്റ് ചെയ്യാനും മാറ്റം വരുത്താനും എളുപ്പമാക്കുന്നു. നല്ല രീതിയിൽ Go ഉപയോഗിക്കാൻ, എല്ലാത്തിനെയും എക്സ്റ്റൻഡ് ചെയ്യണമെന്ന എന്റെ പഴയ ശീലം ഉപേക്ഷിക്കേണ്ടി വന്നു.
Clarity Over Cleverness PHP-യിൽ മാജിക് മെത്തേഡുകളും (magic methods) ഡൈനാമിക് ടൈപ്പിംഗും അനുവദനീയമാണ്. നിങ്ങൾക്ക് വളരെ ബുദ്ധിപരമായ രീതിയിൽ കോഡ് എഴുതാം. എന്നാൽ Go മനഃപൂർവ്വം ലളിതമാണ്. സ്റ്റാൻഡേർഡ് ഫോർമാറ്റിംഗ് ഉപയോഗിക്കാൻ കംപൈലർ നിങ്ങളെ നിർബന്ധിക്കുന്നു, ഉപയോഗിക്കാത്ത വേരിയബിളുകളെ അത് തടയുന്നു. തുടക്കത്തിൽ ഇത് ഒരു നിയന്ത്രണമായി എനിക്ക് തോന്നി. എന്നാൽ ഇപ്പോൾ ഞാൻ ഇതിനെ വിലമതിക്കുന്നു. കോഡ് എഴുതുന്ന വ്യക്തിയെക്കാൾ ഉപരി, അത് വായിക്കുന്ന വ്യക്തിയെ മുൻനിർത്തിയാണ് Go രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. ഒരു പ്രശ്നം ഉണ്ടാകുമ്പോൾ പുലർച്ചെ 2 മണിക്ക് പോലും ലളിതമായ കോഡ് എളുപ്പത്തിൽ പരിഹരിക്കാൻ സാധിക്കും.
ഒരു പുതിയ ഭാഷ പഠിക്കുമ്പോൾ ഏറ്റവും പ്രയാസകരമായ കാര്യം അതിന്റെ പുതിയ സിന്റാക്സ് പഠിക്കുക എന്നതല്ല. മറിച്ച്, നിങ്ങളുടെ കൂടെ കൊണ്ടുനടക്കുന്ന പഴയ ധാരണകൾ മാറ്റുക എന്നതാണ്.
Source: https://dev.to/econ__11/from-php-to-go-what-took-me-longest-to-rewire-2nfn