PHP ಇಂದ Go ವರೆಗೆ: ನನ್ನನ್ನು ಮರುರೂಪಿಸಿಕೊಳ್ಳಲು ಅತಿ ಹೆಚ್ಚು ಸಮಯ ತಗೆದುಕೊಂಡ ವಿಷಯಗಳು
ನಾನು ಏಳು ವರ್ಷಗಳ ಕಾಲ PHP ಬರೆಯುತ್ತಿದ್ದೆ. ಅವುಗಳಲ್ಲಿ ಐದು ವರ್ಷಗಳ ಕಾಲ Laravel ಬಳಸಿದ್ದೆ. Laravel monolith ನಿಂದ microservices ಗೆ ವಲಸೆಯನ್ನು (migration) ಮುನ್ನಡೆಸಲು ನಾನು Go ಗೆ ಬಂದಾಗ, ನನ್ನ ಬಳಿ ಯಾವುದೇ ಟ್ಯುಟೋರಿಯಲ್ ಇರಲಿಲ್ಲ. ಬದಲಾಗಿ, ಒಂದು ದಶಕದ PHP ಅಭ್ಯಾಸಗಳಿದ್ದವು.
ಸಿಂಟ್ಯಾಕ್ಸ್ (syntax) ಕಲಿಯುವುದು ಸುಲಭವಾಗಿತ್ತು. ಒಂದು ಮಧ್ಯಾಹ್ನದಲ್ಲಿ ನೀವು Go ಅನ್ನು ಓದಬಹುದು. ಆದರೆ ಕಷ್ಟಕರವಾದ ಭಾಗವೆಂದರೆ, ನಾನು ಕೋಡ್ ಬಗ್ಗೆ ಯೋಚಿಸುವ ರೀತಿಯನ್ನು ಮರೆತುಬಿಡುವುದು (unlearning).
ನಾನು ಕಲಿಯಲು ತಿಂಗಳುಗಟ್ಟಲೆ ಸಮಯ ತಗೆದುಕೊಂಡ ಮಾನಸಿಕ ಬದಲಾವಣೆಗಳು ಇಲ್ಲಿವೆ:
Error Handling PHP ನಲ್ಲಿ, ನಾನು
try/catchಬಳಸುತ್ತಿದ್ದೆ. ದೋಷಗಳು (errors) ಹೆಚ್ಚಾಗಿ ಅತೃಪ್ತವಾಗಿ (invisibly) ಗ್ಲೋಬಲ್ ಹ್ಯಾಂಡ್ಲರ್ಗೆ ತಲುಪುತ್ತಿದ್ದವು. Go ನಲ್ಲಿ, ದೋಷಗಳು ಮೌಲ್ಯಗಳಾಗಿವೆ (values). ಒಂದು ಫಂಕ್ಷನ್ ತನ್ನ ಕೊನೆಯ ಮೌಲ್ಯವಾಗಿ ದೋಷವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ನೀವು ಅದನ್ನು ಅಲ್ಲೇ ನಿರ್ವಹಿಸಬೇಕು. ಮೊದಲಿಗೆ, ಇದು ಹೆಚ್ಚುವರಿ ಕೆಲಸದಂತೆ ಅನಿಸಿತು. ನಂತರ, ಇದು ವೈಫಲ್ಯವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಕಾಣುವಂತೆ ಮಾಡುತ್ತದೆ ಎಂದು ನನಗೆ ಅರ್ಥವಾಯಿತು. ಒಂದು ಸರ್ವಿಸ್ ವೈಫಲ್ಯಕ್ಕೊಳಗಾದಾಗ, ದೋಷ ಸಂದೇಶವು ಒಂದು ಮಾರ್ಗದರ್ಶಿಯಾಗಿ (breadcrumb trail) ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಇದು ದೊಡ್ಡ stack trace ಇಲ್ಲದೆಯೇ ವೈಫಲ್ಯ ಎಲ್ಲಿ ಸಂಭವಿಸಿತು ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ತಿಳಿಸುತ್ತದೆ.Memory and State PHP 'shared-nothing' ಮಾಡೆಲ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ಪ್ರತಿಯೊಂದು ರಿಕ್ವೆಸ್ಟ್ (request) ಹೊಸದಾಗಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ರಿಕ್ವೆಸ್ಟ್ ಮುಗಿದ ನಂತರ ಪ್ರಕ್ರಿಯೆಯು (process) ಕೊನೆಗೊಳ್ಳುವುದರಿಂದ ಮೆಮೊರಿ ಲೀಕ್ಗಳು (memory leaks) ಅಷ್ಟೊಂದು ಮುಖ್ಯವಾಗುವುದಿಲ್ಲ. ಆದರೆ Go ವಿಭಿನ್ನವಾಗಿದೆ. ಪ್ರಕ್ರಿಯೆಯು ಸಾವಿರಾರು ರಿಕ್ವೆಸ್ಗಳವರೆಗೆ ಜೀವಂತವಾಗಿರುತ್ತದೆ. ಇದರರ್ಥ ಪ್ಯಾಕೇಜ್-ಮಟ್ಟದ ವೇರಿಯೇಬಲ್ (package-level variable) ಪ್ರತಿಯೊಂದು ರಿಕ್ವೆಸ್ಟ್ನಲ್ಲಿಯೂ ಹಂಚಿಕೆಯಾಗುತ್ತದೆ. ಒಂದು ವೇಳೆ ಎರಡು ರಿಕ್ವೆಸ್ಗಳು ಏಕಕಾಲದಲ್ಲಿ ಒಂದು
mapಗೆ ಬರೆಯಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ಇಡೀ ಪ್ರೋಗ್ರಾಂ ಕ್ರ್ಯಾಶ್ ಆಗುತ್ತದೆ. Go ನಲ್ಲಿ, ನೀವು ಕನ್ಕರನ್ಸಿ (concurrency) ಅನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ. ಸುರಕ್ಷಿತವಾಗಿರಿಸಲು ನೀವು race detector ನಂತಹ ಪರಿಕರಗಳನ್ನು ಬಳಸಲೇಬೇಕು.The Role of Context PHP ನಲ್ಲಿ, ರಿಕ್ವೆಸ್ಟ್ ಒಂದು ಮಿತಿಯಾಗಿದೆ (boundary). ರಿಕ್ವೆಸ್ಟ್ ಮುಗಿದ ತಕ್ಷಣ ಎಲ್ಲವೂ ನಿಲ್ಲುತ್ತದೆ. Go ನಲ್ಲಿ, ಯಾವುದೂ ತಾನಾಗಿಯೇ ನಿಲ್ಲುವುದಿಲ್ಲ. ಒಂದು ಕ್ಲೈಂಟ್ ಡಿಸ್ಕನೆಕ್ಟ್ ಆದರೂ, ನಿಮ್ಮ goroutines ಮುಂದುವರಿಯುತ್ತಾ ಸಂಪನ್ಮೂಲಗಳನ್ನು (resources) ವ್ಯರ್ಥ ಮಾಡಬಹುದು. ನಿಮ್ಮ ಕೋಡ್ ಮೂಲಕ ಕ್ಯಾನ್ಸಲೇಶನ್ ಸಿಗ್ನಲ್ಗಳನ್ನು (cancellation signals) ಕಳುಹಿಸಲು ನೀವು
context.Contextಅನ್ನು ಬಳಸಲೇಬೇಕು. ಇದು ಹೆಚ್ಚಿನ ಲೋಡ್ ಅಡಿಯಲ್ಲಿಯೂ ನಿಮ್ಮ ಸರ್ವಿಸ್ ಅನ್ನು ಆರೋಗ್ಯಕರವಾಗಿರಿಸುವ ಬೆನ್ನೆಲುಬಾಗಿದೆ.Composition Over Inheritance Laravel ಬೇಸ್ ಕ್ಲಾಸ್ಗಳನ್ನು (base classes) ವಿಸ್ತರಿಸುವುದರ (extending) ಮೇಲೆ ಹೆಚ್ಚು ಅವಲಂಬಿತವಾಗಿದೆ. ನೀವು ವರ್ತನೆಯನ್ನು ವಾರಸುದಾರಿಕೆ (inheriting behavior) ಮಾಡುವ ಮೂಲಕ ಹೊಸ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಸೇರಿಸುತ್ತೀರಿ. Go ನಲ್ಲಿ ಕ್ಲಾಸ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ (class inheritance) ಇಲ್ಲ. ಇದು ಇಂಟರ್ಫೇಸ್ಗಳನ್ನು (interfaces) ಬಳಸುತ್ತದೆ, ಇವುಗಳು ಅಂತರ್ಗತವಾಗಿ (implicitly) ಪೂರೈಸಲ್ಪಡುತ್ತವೆ. ನೀವು ಎಲ್ಲಿ ಬಳಸುತ್ತೀರೋ ಅಲ್ಲಿ ನಿಮಗೆ ಏನು ಬೇಕೋ ಅದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ಇದು ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ಬದಲಾಯಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ. ಉತ್ತಮ Go ಕೋಡ್ ಬರೆಯಲು, ಎಲ್ಲವನ್ನೂ ವಿಸ್ತರಿಸಬೇಕೆಂಬ ನನ್ನ ಸಹಜ ಪ್ರವೃತ್ತಿಯನ್ನು ನಾನು ಬಿಡಬೇಕಾಯಿತು.
Clarity Over Cleverness PHP ಮ್ಯಾಜಿಕ್ ಮೆಥಡ್ಗಳು (magic methods) ಮತ್ತು ಡೈನಾಮಿಕ್ ಟೈಪಿಂಗ್ ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ನೀವು ಚತುರವಾದ, ಅಭಿವ್ಯಕ್ತಿಕ ಶಕ್ತಿಯುತವಾದ (expressive) ಕೋಡ್ ಬರೆಯಬಹುದು. ಆದರೆ Go ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ 'ಬೋರಿಂಗ್' ಆಗಿದೆ. ಕಾಂಪೈಲರ್ (compiler) ನಿಮ್ಮನ್ನು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಬಳಸಲು ಒತ್ತಾಯಿಸುತ್ತದೆ ಮತ್ತು ಬಳಕೆಯಾಗದ ವೇರಿಯೇಬಲ್ಗಳನ್ನು ತಡೆಯುತ್ತದೆ. ಮೊದಲಿಗೆ, ಇದು ನಿರ್ಬಂಧಿತವಾಗಿ ಅನಿಸಿತು. ಈಗ, ನಾನು ಅದರ ಮೌಲ್ಯವನ್ನು ಅರಿಯುತ್ತೇನೆ. Go ಕೋಡ್ ಬರೆಯುವ ವ್ಯಕ್ತಿಗಾಗಿ ಅಲ್ಲ, ಅದನ್ನು ಓದುವ ವ್ಯಕ್ತಿಗಾಗಿ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಯಾವುದಾದರೂ ಸಮಸ್ಯೆಯ ಸಂದರ್ಭದಲ್ಲಿ ರಾತ್ರಿ 2 ಗಂಟೆಗೆ ಬೋರಿಂಗ್ ಕೋಡ್ ಅನ್ನು ಸರಿಪಡಿಸುವುದು ಸುಲಭ.
ಹೊಸ ಭಾಷೆಯನ್ನು ಕಲಿಯುವ ಕಷ್ಟದ ಭಾಗ ಹೊಸ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅಲ್ಲ. ಬದಲಾಗಿ, ನೀವು ಜೊತೆಯಲ್ಲಿ ಹೊತ್ತು ತರುವ ಹಳೆಯ ಕಲ್ಪನೆಗಳು (assumptions).
Source: https://dev.to/econ__11/from-php-to-go-what-took-me-longest-to-rewire-2nfn