𝗣𝗮𝗰𝗸𝗮𝗴𝗲.𝗷𝘀𝗼𝗻 𝘃𝘀 𝗴𝗼.𝗺𝗼𝗱: 𝗪𝗵𝗲𝗿𝗲 𝗗𝗶𝗱 𝘁𝗵𝗲 𝗩𝗲𝗿𝘀𝗶𝗼𝗻 𝗙𝗶𝗲𝗹𝗱 𝗚𝗼?
நீங்கள் JavaScript-லிருந்து Go-விற்கு மாறினால், ஒரு விஷயம் உங்களை ஆச்சரியப்படுத்தும்.
ஒரு package.json கோப்பைத் திறக்கவும். அதன் உச்சியில் ஒரு version field இருப்பதை நீங்கள் காண்பீர்கள். அதை வாசிப்பது எளிது. ஒரு pull request மூலம் அதை மாற்ற முடியும். அது உங்கள் குறியீட்டிற்குள்ளேயே (code) இருக்கும்.
இப்போது ஒரு go.mod கோப்பைத் திறக்கவும்.
அங்கே வெர்ஷன் இல்லை. இது தவறு அல்ல. இது ஒரு தெரிவு (choice).
Go உங்கள் சொந்த மாட்யூல் (module) ஆகியவற்றிற்கு ஒரு version field-ஐப் பயன்படுத்துவதில்லை. அதற்குப் பதிலாக அது git tags-ஐப் பயன்படுத்துகிறது.
இது எப்படிச் செயல்படுகிறது:
• நீங்கள் git tag v1.2.3 என்று இயக்குவீர்கள்
• அந்தத் டேக்-ஐ (tag) உங்கள் ரெப்போசிட்டரிக்கு (repository) புஷ் செய்வீர்கள்
• அந்தத் டேக் தான் உங்கள் வெர்ஷனாக மாறும்
யாராவது go get என்று இயக்கும்போது, சரியான கமிட்டை (commit) கண்டறிய Go உங்கள் git tags-ஐப் பார்க்கும். அந்தத் டேக் தான் உண்மையான ஆதாரமாக (single source of truth) அமைகிறது.
இந்த வடிவமைப்பிற்கு ஒரு முக்கிய பலம் உள்ளது. ஒரு வெர்ஷன் ஒருபோதும் தவறான குறியீட்டைக் (code) காட்டாது. npm-இல், வெளியிடப்பட்ட குறியீடும் (published code) வெர்ஷன் ஃபீல்டும் ஒன்றுக்கொன்று மாறுபடலாம். ஆனால் Go-வில், அவை இரண்டும் ஒன்றே. வெர்ஷன் என்பதுதான் அந்த கமிட் (commit).
இருப்பினும், இது உங்கள் பணிப்பாய்வை (workflow) மாற்றுகிறது:
- தெரிவுத்திறன் (Visibility): ஒரு கோப்பைப் பார்ப்பதன் மூலம் உங்கள் வெர்ஷனை உங்களால் பார்க்க முடியாது. அதைக் கண்டறிய நீங்கள் ஒரு git command-ஐ இயக்க வேண்டும்.
- கோட் ரிவியூக்கள் (Code Reviews): வெர்ஷன் மாற்றம் (version bump) ஒரு கோட் டிஃபில் (code diff) தெரியாது. இது ஒரு டேக் புஷ் (tag push) மட்டுமே, குறியீடு மாற்றம் (code change) அல்ல.
- லோக்கல் பில்டுகள் (Local Builds): டேக் இல்லாத ஒரு கமிட், குழப்பமான ஒரு pseudo-version-ஐக் காட்டும். நீங்கள் கமிட்டை டேக் செய்த பின்னரே ஒரு தெளிவான வெர்ஷனைப் பெற முடியும்.
- மேஜர் வெர்ஷன்கள் (Major Versions): இதுதான் மிகப்பெரிய மாற்றம். Go-வில், v2 மற்றும் அதற்கு மேற்பட்ட வெர்ஷன்கள் இம்போர்ட் பாதையில் (import path) வெர்ஷனைச் சேர்க்க வேண்டும்.
உதாரணம்: v1 uses github.com/you/my-app v2 uses github.com/you/my-app/v2
இது ஒரே நிரல் (program), மோதல்கள் (conflict) இன்றி ஒரே லைப்ரரியின் (library) இரண்டு வெவ்வேறு மேஜர் வெர்ஷன்களைப் பயன்படுத்த அனுமதிக்கிறது.
மற்ற பெரும்பாலான மொழிகள் வெர்ஷனை ஒரு கோப்பில் வைத்திருக்கின்றன: • Node: package.json • Rust: Cargo.toml • Python: pyproject.toml • Java: pom.xml
Go ஒரு விதிவிலக்கு. இது முற்றிலும் git tags-ஐ மட்டுமே நம்பியுள்ளது.
உங்களுக்கு npm அனுபவம் தேவைப்பட்டால், ldflags-ஐப் பயன்படுத்தி பில்ட் நேரத்திலேயே (build time) உங்கள் பைனரியில் (binary) வெர்ஷனைச் சேர்க்கலாம். இது உங்கள் ஆப் (app) ஒரு வெர்ஷன் கட்டளைக்கு (version command) பதிலளிக்க உதவும்.
இதில் உள்ள சமரசத் தன்மை (trade-off) எளிமையானது: ஒரு வெர்ஷன் ஃபீல்டை வாசிப்பதும் ரிவியூ செய்வதும் எளிது, ஆனால் அது தவறான தகவலைத் தரலாம். ஒரு git tag-ஐக் காண்பது கடினம், ஆனால் அது எப்போதும் உண்மையானது.
Go வசதியை விட உண்மையைத் தேர்ந்தெடுத்தது.
Go டெவலப்பர்களிடம்: இதுதான் சிறந்த மாடலா? கருவிகள் (tools) அதை git tag-உடன் சரிபார்த்தால், நீங்கள் go.mod-இல் ஒரு version field-ஐ விரும்புவீர்களா?
Source: https://dev.to/dalirnet/packagejson-vs-gomod-where-did-the-version-field-go-3301