𝗣𝗮𝗰𝗸𝗮𝗴𝗲.𝗷𝘀𝗼𝗻 𝘃𝘀 𝗴𝗼.𝗺𝗼𝗱: ವರ್ಷನ್ ಫೀಲ್ಡ್ (Version Field) ಎಲ್ಲಿ ಮಾಯವಾಯಿತು?
ನೀವು JavaScript ನಿಂದ Go ಗೆ ಬದಲಾದರೆ, ಒಂದು ವಿಷಯ ನಿಮಗೆ ಆಶ್ಚರ್ಯ ತರಬಹುದು.
ಒಂದು package.json ಫೈಲ್ ಅನ್ನು ತೆರೆಯಿರಿ. ಅದರ ಮೇಲ್ಭಾಗದಲ್ಲೇ ನೀವು ವರ್ಷನ್ ಫೀಲ್ಡ್ ಅನ್ನು ಕಾಣಬಹುದು. ಇದನ್ನು ಓದುವುದು ಸುಲಭ. ನೀವು ಇದನ್ನು pull request ನಲ್ಲಿ ಬದಲಾಯಿಸಬಹುದು. ಇದು ನಿಮ್ಮ ಕೋಡ್ನ ಒಳಗೇ ಇರುತ್ತದೆ.
ಈಗ ಒಂದು go.mod ಫೈಲ್ ಅನ್ನು ತೆರೆಯಿರಿ.
ಅಲ್ಲಿ ವರ್ಷನ್ ಇಲ್ಲ. ಇದು ತಪ್ಪಲ್ಲ. ಇದು ಒಂದು ಆಯ್ಕೆ.
Go ನಿಮ್ಮ ಸ್ವಂತ ಮಾಡ್ಯೂಲ್ಗಾಗಿ ವರ್ಷನ್ ಫೀಲ್ಡ್ ಅನ್ನು ಬಳಸುವುದಿಲ್ಲ. ಬದಲಾಗಿ ಅದು git tags ಅನ್ನು ಬಳಸುತ್ತದೆ.
ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ: • ನೀವು git tag v1.2.3 ಅನ್ನು ರನ್ ಮಾಡ್ತೀರಾ • ನೀವು ಆ ಟ್ಯಾಗ್ ಅನ್ನು ನಿಮ್ಮ ರೆಪೊಸಿಟರಿಗೆ (repository) ಪುಶ್ ಮಾಡ್ತೀರಾ • ಆ ಟ್ಯಾಗ್ ನಿಮ್ಮ ವರ್ಷನ್ ಆಗುತ್ತದೆ
ಯಾರಾದರೂ go get ಅನ್ನು ರನ್ ಮಾಡಿದಾಗ, ಸರಿಯಾದ commit ಅನ್ನು ಹುಡುಕಲು Go ನಿಮ್ಮ git tags ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಆ ಟ್ಯಾಗ್ ಒಂದೇ ಸತ್ಯದ ಮೂಲ (single source of truth).
ಈ ವಿನ್ಯಾಸವು ಒಂದು ದೊಡ್ಡ ಶಕ್ತಿಯನ್ನು ಹೊಂದಿದೆ. ವರ್ಷನ್ ಎಂದಿಗೂ ತಪ್ಪಾದ ಕೋಡ್ ಅನ್ನು ತೋರಿಸುವುದಿಲ್ಲ. npm ನಲ್ಲಿ, ಪ್ರಕಟವಾದ ಕೋಡ್ ಮತ್ತು ವರ್ಷನ್ ಫೀಲ್ಡ್ ನಡುವೆ ವ್ಯತ್ಯಾಸವಿರಬಹುದು. ಆದರೆ Go ನಲ್ಲಿ, ಅವೆರಡೂ ಒಂದೇ. ವರ್ಷನ್ ಎಂದರೆ ಅದುವೇ commit.
ಆದಾಗ್ಯೂ, ಇದು ನಿಮ್ಮ ಕೆಲಸದ ವಿಧಾನವನ್ನು (workflow) ಬದಲಾಯಿಸುತ್ತದೆ:
- ದೃಶ್ಯತೆ (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
ಇದು ಯಾವುದೇ ಸಂಘರ್ಷವಿಲ್ಲದೆ (conflict) ಒಂದೇ ಪ್ರೋಗ್ರಾಂ ಒಂದೇ ಲೈಬ್ರರಿಯ ಎರಡು ವಿಭಿನ್ನ ಮೇಜರ್ ವರ್ಷನ್ಗಳನ್ನು ಬಳಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಇತರ ಹೆಚ್ಚಿನ ಭಾಷೆಗಳು ವರ್ಷನ್ ಅನ್ನು ಫೈಲ್ನಲ್ಲಿ ಇರಿಸುತ್ತವೆ: • Node: package.json • Rust: Cargo.toml • Python: pyproject.toml • Java: pom.xml
Go ಈ ವಿಷಯದಲ್ಲಿ ಭಿನ್ನವಾಗಿದೆ. ಇದು ಸಂಪೂರ್ಣವಾಗಿ git tags ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ.
ನಿಮಗೆ npm ಅನುಭವ ಬೇಕೆನಿಸಿದರೆ, ನೀವು build ಸಮಯದಲ್ಲಿ ldflags ಬಳಸಿ ನಿಮ್ಮ binary ನಲ್ಲಿ ವರ್ಷನ್ ಅನ್ನು ಸೇರಿಸಬಹುದು. ಇದು ನಿಮ್ಮ ಆ್ಯಪ್ ವರ್ಷನ್ ಕಮಾಂಡ್ಗೆ ಪ್ರತಿಕ್ರಿಯಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಇದರ ಲಾಭ-ನಷ್ಟ (trade-off) ಸರಳವಾಗಿದೆ: ವರ್ಷನ್ ಫೀಲ್ಡ್ ಅನ್ನು ಓದುವುದು ಮತ್ತು ಪರಿಶೀಲಿಸುವುದು ಸುಲಭ, ಆದರೆ ಅದು ಸುಳ್ಳು ಹೇಳಬಹುದು. git tag ಅನ್ನು ನೋಡುವುದು ಕಷ್ಟ, ಆದರೆ ಅದು ಯಾವಾಗಲೂ ಸತ್ಯವಾಗಿರುತ್ತದೆ.
Go ಸೌಕರ್ಯಕ್ಕಿಂತ ಸತ್ಯಕ್ಕೆ ಆದ್ಯತೆ ನೀಡಿದೆ.
Go ಡೆವಲಪರ್ಗಳಿಗೆ: ಇದು ಅತ್ಯುತ್ತಮ ಮಾದರಿಯೇ? ಒಂದು ವೇಳೆ ಟೂಲ್ಗಳು git tag ಮೂಲಕ ಅದನ್ನು ಪರಿಶೀಲಿಸುತ್ತಿದ್ದರೆ, ನೀವು go.mod ನಲ್ಲಿ ವರ್ಷನ್ ಫೀಲ್ಡ್ ಅನ್ನು ಇಷ್ಟಪಡುತ್ತೀರಾ?
ಮೂಲ (Source): https://dev.to/dalirnet/packagejson-vs-gomod-where-did-the-version-field-go-3301