𝗣𝗮𝗰𝗸𝗮𝗴𝗲.𝗷𝘀𝗼𝗻 vs 𝗴𝗼.𝗺𝗼𝗱: വേർഷൻ ഫീൽഡ് എവിടെപ്പോയി?
നിങ്ങൾ JavaScript-ൽ നിന്ന് Go-ലേക്ക് മാറുന്നുണ്ടെങ്കിൽ, ഒരു കാര്യം നിങ്ങളെ അത്ഭുതപ്പെടുത്തും.
ഒരു package.json ഫയൽ തുറന്നു നോക്കൂ. അതിന്റെ മുകളിൽ തന്നെ നിങ്ങൾക്ക് ഒരു version field കാണാം. ഇത് വായിക്കാൻ എളുപ്പമാണ്. ഒരു pull request വഴി നിങ്ങൾക്ക് ഇത് മാറ്റാൻ സാധിക്കും. ഇത് നിങ്ങളുടെ കോഡിനുള്ളിൽ തന്നെ നിലനിൽക്കുന്നു.
ഇനി ഒരു go.mod ഫയൽ തുറക്കൂ.
അവിടെ വേർഷൻ കാണാനില്ല. ഇതൊരു തെറ്റല്ല, മറിച്ച് ഒരു തിരഞ്ഞെടുപ്പാണ്.
നിങ്ങളുടെ സ്വന്തം മോഡ്യൂളിനായി Go ഒരു version field ഉപയോഗിക്കുന്നില്ല. പകരം അത് git tags ആണ് ഉപയോഗിക്കുന്നത്.
ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു: • നിങ്ങൾ git tag v1.2.3 റൺ ചെയ്യുന്നു • നിങ്ങൾ ആ ടാഗ് നിങ്ങളുടെ റെപ്പോസിറ്ററിയിലേക്ക് പുഷ് ചെയ്യുന്നു • ആ ടാഗ് നിങ്ങളുടെ വേർഷനായി മാറുന്നു
ആരെങ്കിലും go get റൺ ചെയ്യുമ്പോൾ, ശരിയായ commit കണ്ടെത്താനായി Go നിങ്ങളുടെ git tags പരിശോധിക്കുന്നു. ആ ടാഗ് ആണ് ഏക സ്രോതസ്സ് (single source of truth).
ഈ ഡിസൈനിന് വലിയൊരു ഗുണമുണ്ട്. ഒരു വേർഷന് ഒരിക്കലും തെറ്റായ കോഡിലേക്ക് വിരൽ ചൂണ്ടാൻ കഴിയില്ല. npm-ൽ, പബ്ലിഷ് ചെയ്ത കോഡും വേർഷൻ ഫീൽഡും തമ്മിൽ വ്യത്യാസം വരാൻ സാധ്യതയുണ്ട്. എന്നാൽ Go-യിൽ അവ രണ്ടും ഒന്നാണ്. വേർഷൻ എന്നാൽ ആ commit തന്നെയാണ്.
എന്നിരുന്നാലും, ഇത് നിങ്ങളുടെ വർക്ക്ഫ്ലോയിൽ മാറ്റങ്ങൾ വരുത്തുന്നു:
- വിസിബിലിറ്റി (Visibility): ഒരു ഫയൽ നോക്കിയാൽ മാത്രം നിങ്ങൾക്ക് വേർഷൻ കാണാൻ കഴിയില്ല. അത് കണ്ടെത്താൻ നിങ്ങൾ ഒരു git കമാൻഡ് റൺ ചെയ്യണം.
- കോഡ് റിവ്യൂസ് (Code Reviews): ഒരു വേർഷൻ മാറ്റം (version bump) കോഡ് ഡിഫിൽ (code diff) കാണില്ല. ഇതൊരു ടാഗ് പുഷ് ആണ്, കോഡിലെ മാറ്റമല്ല.
- ലോക്കൽ ബിൽഡുകൾ (Local Builds): ടാഗ് ഇല്ലാത്ത ഒരു commit കാണിക്കുന്നത് കുഴപ്പമുള്ള ഒരു pseudo-version ആണ്. നിങ്ങൾ ആ commit ടാഗ് ചെയ്തതിന് ശേഷം മാത്രമേ വൃത്തിയുള്ള ഒരു വേർഷൻ ലഭിക്കൂ.
- മേജർ വേർഷനുകൾ (Major Versions): ഇതാണ് ഏറ്റവും വലിയ മാറ്റം. Go-യിൽ, v2-നും അതിനു മുകളിലുള്ളവയ്ക്കും ഇംപോർട്ട് പാത്തിൽ (import path) വേർഷൻ ഉൾപ്പെടുത്തണം.
ഉദാഹരണം: v1 ഉപയോഗിക്കുന്നത് github.com/you/my-app v2 ഉപയോഗിക്കുന്നത് github.com/you/my-app/v2
ഇത് ഒരേ ലൈബ്രറിയുടെ രണ്ട് വ്യത്യസ്ത മേജർ വേർഷനുകൾ യാതൊരു തടസ്സവുമില്ലാതെ ഒരു പ്രോഗ്രാമിന് ഉപയോഗിക്കാൻ അനുവദിക്കുന്നു.
മിക്ക മറ്റ് ഭാഷകളും വേർഷൻ ഒരു ഫയലിൽ സൂക്ഷിക്കുന്നു: • Node: package.json • Rust: Cargo.toml • Python: pyproject.toml • Java: pom.xml
Go ഇതിൽ നിന്നും വ്യത്യസ്തമാണ്. അത് പൂർണ്ണമായും git tags-നെ ആശ്രയിക്കുന്നു.
നിങ്ങൾക്ക് npm അനുഭവം നഷ്ടപ്പെടുന്നുണ്ടെങ്കിൽ, ldflags ഉപയോഗിച്ച് ബിൽഡ് സമയത്ത് നിങ്ങളുടെ ബൈനറിയിലേക്ക് (binary) വേർഷൻ ഉൾപ്പെടുത്താം. ഇത് നിങ്ങളുടെ ആപ്പിന് ഒരു version കമാൻഡിനോട് പ്രതികരിക്കാൻ സഹായിക്കുന്നു.
ഇതിലെ ഗുണദോഷങ്ങൾ ലളിതമാണ്: ഒരു version field വായിക്കാനും റിവ്യൂ ചെയ്യാനും എളുപ്പമാണ്, പക്ഷേ അത് തെറ്റായ വിവരങ്ങൾ നൽകിയേക്കാം. ഒരു git tag കാണാൻ പ്രയാസമാണ്, പക്ഷേ അത് എപ്പോഴും സത്യമാണ്.
സൗകര്യത്തേക്കാൾ സത്യത്തിന് Go മുൻഗണന നൽകി.
Go ഡെവലപ്പർമാരോട്: ഇതാണോ ഏറ്റവും മികച്ച മോഡൽ? ടൂളുകൾ git ടാഗുമായി ഒത്തുനോക്കി പരിശോധിക്കുന്നുണ്ടെങ്കിൽ, നിങ്ങൾ go.mod-ൽ ഒരു version field വേണമെന്ന് ആഗ്രഹിക്കുന്നുണ്ടോ?
Source: https://dev.to/dalirnet/packagejson-vs-gomod-where-did-the-version-field-go-3301