ಇಂದು ನಾವು ಪೈಥಾನ್ ಕೋಡ್‌ನ ಹಲವಾರು ಮಿಲಿಯನ್ ಲೈನ್‌ಗಳಿಗೆ ಡ್ರಾಪ್‌ಬಾಕ್ಸ್ ಟೈಪ್ ಕಂಟ್ರೋಲ್ ಅನ್ನು ಹೇಗೆ ಆಯೋಜಿಸಲಾಗಿದೆ ಎಂಬುದರ ಕುರಿತು ವಸ್ತುವಿನ ಅನುವಾದದ ಎರಡನೇ ಭಾಗವನ್ನು ಪ್ರಕಟಿಸುತ್ತಿದ್ದೇವೆ.
→
ಅಧಿಕೃತ ಪ್ರಕಾರದ ಬೆಂಬಲ (PEP 484)
ಹ್ಯಾಕ್ ವೀಕ್ 2014 ರ ಸಮಯದಲ್ಲಿ ಡ್ರಾಪ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಮೈಪಿಯೊಂದಿಗೆ ನಮ್ಮ ಮೊದಲ ಗಂಭೀರ ಪ್ರಯೋಗಗಳನ್ನು ನಡೆಸಿದ್ದೇವೆ. ಹ್ಯಾಕ್ ವೀಕ್ ಎಂಬುದು ಡ್ರಾಪ್‌ಬಾಕ್ಸ್ ಹೋಸ್ಟ್ ಮಾಡಿದ ಒಂದು ವಾರದ ಕಾರ್ಯಕ್ರಮವಾಗಿದೆ. ಈ ಸಮಯದಲ್ಲಿ, ಉದ್ಯೋಗಿಗಳು ತಮಗೆ ಬೇಕಾದುದನ್ನು ಕೆಲಸ ಮಾಡಬಹುದು! ಡ್ರಾಪ್‌ಬಾಕ್ಸ್‌ನ ಕೆಲವು ಪ್ರಸಿದ್ಧ ತಂತ್ರಜ್ಞಾನ ಯೋಜನೆಗಳು ಈ ರೀತಿಯ ಘಟನೆಗಳಲ್ಲಿ ಪ್ರಾರಂಭವಾದವು. ಈ ಪ್ರಯೋಗದ ಪರಿಣಾಮವಾಗಿ, ಯೋಜನೆಯು ವ್ಯಾಪಕ ಬಳಕೆಗೆ ಇನ್ನೂ ಸಿದ್ಧವಾಗಿಲ್ಲದಿದ್ದರೂ, mypy ಭರವಸೆಯಂತೆ ಕಾಣುತ್ತದೆ ಎಂದು ನಾವು ತೀರ್ಮಾನಿಸಿದ್ದೇವೆ.
ಆ ಸಮಯದಲ್ಲಿ, ಪೈಥಾನ್ ಪ್ರಕಾರದ ಸುಳಿವು ವ್ಯವಸ್ಥೆಗಳನ್ನು ಪ್ರಮಾಣೀಕರಿಸುವ ಕಲ್ಪನೆಯು ಗಾಳಿಯಲ್ಲಿತ್ತು. ನಾನು ಹೇಳಿದಂತೆ, ಪೈಥಾನ್ 3.0 ರಿಂದ ಕಾರ್ಯಗಳಿಗಾಗಿ ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳನ್ನು ಬಳಸಲು ಸಾಧ್ಯವಾಯಿತು, ಆದರೆ ಇವುಗಳು ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಸಿಂಟ್ಯಾಕ್ಸ್ ಮತ್ತು ಸೆಮ್ಯಾಂಟಿಕ್ಸ್ ಇಲ್ಲದೆ ಕೇವಲ ಅನಿಯಂತ್ರಿತ ಅಭಿವ್ಯಕ್ತಿಗಳಾಗಿವೆ. ಪ್ರೋಗ್ರಾಂ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಮಯದಲ್ಲಿ, ಈ ಟಿಪ್ಪಣಿಗಳನ್ನು ಬಹುಪಾಲು ಸರಳವಾಗಿ ನಿರ್ಲಕ್ಷಿಸಲಾಗಿದೆ. ಹ್ಯಾಕ್ ವೀಕ್ ನಂತರ, ನಾವು ಶಬ್ದಾರ್ಥವನ್ನು ಪ್ರಮಾಣೀಕರಿಸುವ ಕೆಲಸವನ್ನು ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ. ಈ ಕೆಲಸವು ಹೊರಹೊಮ್ಮಲು ಕಾರಣವಾಯಿತು (ಗುಯಿಡೋ ವ್ಯಾನ್ ರೋಸಮ್, Łukasz Langa ಮತ್ತು ನಾನು ಈ ಡಾಕ್ಯುಮೆಂಟ್‌ನಲ್ಲಿ ಸಹಕರಿಸಿದ್ದೇವೆ).
ನಮ್ಮ ಉದ್ದೇಶಗಳನ್ನು ಎರಡು ಕಡೆಯಿಂದ ನೋಡಬಹುದು. ಮೊದಲನೆಯದಾಗಿ, ಸಂಪೂರ್ಣ ಪೈಥಾನ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯು ಟೈಪ್ ಸುಳಿವುಗಳನ್ನು ಬಳಸುವ ಸಾಮಾನ್ಯ ವಿಧಾನವನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಬಹುದು ಎಂದು ನಾವು ಭಾವಿಸಿದ್ದೇವೆ (ಪೈಥಾನ್‌ನಲ್ಲಿ "ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳಿಗೆ" ಸಮಾನವಾದ ಪದವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ). ಇದು ಸಂಭವನೀಯ ಅಪಾಯಗಳನ್ನು ನೀಡಿದರೆ, ಅನೇಕ ಪರಸ್ಪರ ಹೊಂದಾಣಿಕೆಯಾಗದ ವಿಧಾನಗಳನ್ನು ಬಳಸುವುದಕ್ಕಿಂತ ಉತ್ತಮವಾಗಿರುತ್ತದೆ. ಎರಡನೆಯದಾಗಿ, ನಾವು ಪೈಥಾನ್ ಸಮುದಾಯದ ಅನೇಕ ಸದಸ್ಯರೊಂದಿಗೆ ರೀತಿಯ ಟಿಪ್ಪಣಿ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಬಹಿರಂಗವಾಗಿ ಚರ್ಚಿಸಲು ಬಯಸಿದ್ದೇವೆ. ಪೈಥಾನ್ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳ ವಿಶಾಲ ಜನಸಮೂಹದ ದೃಷ್ಟಿಯಲ್ಲಿ ಭಾಷೆಯ ಮೂಲ ವಿಚಾರಗಳಿಂದ ನಾವು "ಧರ್ಮಭ್ರಷ್ಟರಾಗಿ" ಕಾಣಲು ಬಯಸುವುದಿಲ್ಲ ಎಂಬ ಅಂಶದಿಂದ ಈ ಬಯಕೆಯು ಭಾಗಶಃ ನಿರ್ದೇಶಿಸಲ್ಪಟ್ಟಿದೆ. ಇದು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಟೈಪ್ ಮಾಡಲಾದ ಭಾಷೆಯಾಗಿದೆ, ಇದನ್ನು "ಡಕ್ ಟೈಪಿಂಗ್" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಸಮುದಾಯದಲ್ಲಿ, ಪ್ರಾರಂಭದಲ್ಲಿ, ಸ್ಥಿರ ಟೈಪಿಂಗ್ ಕಲ್ಪನೆಯ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಅನುಮಾನಾಸ್ಪದ ವರ್ತನೆ ಸಹಾಯ ಮಾಡಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ಆದರೆ ಉದ್ಭವಿಸುತ್ತದೆ. ಆದರೆ ಸ್ಥಿರ ಟೈಪಿಂಗ್ ಕಡ್ಡಾಯವಾಗಿರುವುದಿಲ್ಲ ಎಂದು ಸ್ಪಷ್ಟವಾದ ನಂತರ ಆ ಭಾವನೆಯು ಅಂತಿಮವಾಗಿ ಕ್ಷೀಣಿಸಿತು (ಮತ್ತು ಅದು ನಿಜವಾಗಿಯೂ ಉಪಯುಕ್ತವಾಗಿದೆ ಎಂದು ಜನರು ಅರಿತುಕೊಂಡ ನಂತರ).
ಅಂತಿಮವಾಗಿ ಅಳವಡಿಸಿಕೊಂಡ ಟೈಪ್ ಸುಳಿವು ಸಿಂಟ್ಯಾಕ್ಸ್ ಆ ಸಮಯದಲ್ಲಿ mypy ಬೆಂಬಲಿಸಿದ್ದನ್ನು ಹೋಲುತ್ತದೆ. PEP 484 ಅನ್ನು 3.5 ರಲ್ಲಿ ಪೈಥಾನ್ 2015 ನೊಂದಿಗೆ ಬಿಡುಗಡೆ ಮಾಡಲಾಯಿತು. ಪೈಥಾನ್ ಇನ್ನು ಮುಂದೆ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಟೈಪ್ ಮಾಡಲಾದ ಭಾಷೆಯಾಗಿರಲಿಲ್ಲ. ಈ ಘಟನೆಯನ್ನು ಪೈಥಾನ್ ಇತಿಹಾಸದಲ್ಲಿ ಮಹತ್ವದ ಮೈಲಿಗಲ್ಲು ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.
ವಲಸೆಯ ಪ್ರಾರಂಭ
2015 ರ ಕೊನೆಯಲ್ಲಿ, ಡ್ರಾಪ್‌ಬಾಕ್ಸ್ ಮೈಪಿಯಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ಮೂರು ಜನರ ತಂಡವನ್ನು ರಚಿಸಿತು. ಅವರಲ್ಲಿ ಗಿಡೋ ವ್ಯಾನ್ ರೋಸಮ್, ಗ್ರೆಗ್ ಪ್ರೈಸ್ ಮತ್ತು ಡೇವಿಡ್ ಫಿಶರ್ ಸೇರಿದ್ದಾರೆ. ಆ ಕ್ಷಣದಿಂದ, ಪರಿಸ್ಥಿತಿಯು ಅತ್ಯಂತ ವೇಗವಾಗಿ ಬೆಳೆಯಲು ಪ್ರಾರಂಭಿಸಿತು. ಮೈಪಿಯ ಬೆಳವಣಿಗೆಗೆ ಮೊದಲ ಅಡಚಣೆಯೆಂದರೆ ಕಾರ್ಯಕ್ಷಮತೆ. ನಾನು ಮೇಲೆ ಸುಳಿವು ನೀಡಿದಂತೆ, ಯೋಜನೆಯ ಆರಂಭಿಕ ದಿನಗಳಲ್ಲಿ ನಾನು mypy ಅನುಷ್ಠಾನವನ್ನು C ಗೆ ಭಾಷಾಂತರಿಸುವ ಬಗ್ಗೆ ಯೋಚಿಸಿದೆ, ಆದರೆ ಈ ಕಲ್ಪನೆಯನ್ನು ಇದೀಗ ಪಟ್ಟಿಯಿಂದ ದಾಟಿದೆ. ನಾವು CPython ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸಿಸ್ಟಮ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುವಲ್ಲಿ ಸಿಲುಕಿಕೊಂಡಿದ್ದೇವೆ, ಇದು mypy ನಂತಹ ಸಾಧನಗಳಿಗೆ ಸಾಕಷ್ಟು ವೇಗವನ್ನು ಹೊಂದಿಲ್ಲ. (JIT ಕಂಪೈಲರ್‌ನೊಂದಿಗೆ ಪರ್ಯಾಯ ಪೈಥಾನ್ ಅನುಷ್ಠಾನವಾದ PyPy ಯೋಜನೆಯು ನಮಗೆ ಸಹಾಯ ಮಾಡಲಿಲ್ಲ.)
ಅದೃಷ್ಟವಶಾತ್, ಕೆಲವು ಅಲ್ಗಾರಿದಮಿಕ್ ಸುಧಾರಣೆಗಳು ಇಲ್ಲಿ ನಮ್ಮ ಸಹಾಯಕ್ಕೆ ಬಂದಿವೆ. ಮೊದಲ ಶಕ್ತಿಯುತ "ವೇಗವರ್ಧಕ" ಹೆಚ್ಚುತ್ತಿರುವ ತಪಾಸಣೆಯ ಅನುಷ್ಠಾನವಾಗಿದೆ. ಈ ಸುಧಾರಣೆಯ ಹಿಂದಿನ ಕಲ್ಪನೆಯು ಸರಳವಾಗಿದೆ: ಹಿಂದಿನ mypy ರನ್‌ನಿಂದ ಎಲ್ಲಾ ಮಾಡ್ಯೂಲ್‌ನ ಅವಲಂಬನೆಗಳು ಬದಲಾಗದಿದ್ದರೆ, ಅವಲಂಬನೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಹಿಂದಿನ ರನ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ಡೇಟಾವನ್ನು ನಾವು ಬಳಸಬಹುದು. ನಾವು ಮಾರ್ಪಡಿಸಿದ ಫೈಲ್‌ಗಳಲ್ಲಿ ಮತ್ತು ಅವುಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುವ ಫೈಲ್‌ಗಳಲ್ಲಿ ಮಾತ್ರ ಟೈಪ್ ಚೆಕ್ ಮಾಡಬೇಕಾಗಿದೆ. Mypy ಇನ್ನೂ ಸ್ವಲ್ಪ ಮುಂದೆ ಹೋಗಿದೆ: ಮಾಡ್ಯೂಲ್‌ನ ಬಾಹ್ಯ ಇಂಟರ್ಫೇಸ್ ಬದಲಾಗದಿದ್ದರೆ, ಈ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಆಮದು ಮಾಡಿದ ಇತರ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಮತ್ತೊಮ್ಮೆ ಪರಿಶೀಲಿಸುವ ಅಗತ್ಯವಿಲ್ಲ ಎಂದು mypy ಊಹಿಸಿದೆ.
ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್‌ನ ದೊಡ್ಡ ಮೊತ್ತವನ್ನು ಟಿಪ್ಪಣಿ ಮಾಡುವಾಗ ಹೆಚ್ಚುತ್ತಿರುವ ತಪಾಸಣೆ ನಮಗೆ ಸಾಕಷ್ಟು ಸಹಾಯ ಮಾಡಿದೆ. ಈ ಪ್ರಕ್ರಿಯೆಯು ಸಾಮಾನ್ಯವಾಗಿ ಮೈಪಿಯ ಅನೇಕ ಪುನರಾವರ್ತಿತ ರನ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ಏಕೆಂದರೆ ಟಿಪ್ಪಣಿಗಳನ್ನು ಕ್ರಮೇಣ ಕೋಡ್‌ಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಕ್ರಮೇಣ ಸುಧಾರಿಸಲಾಗುತ್ತದೆ. mypy ಯ ಮೊದಲ ಓಟವು ಇನ್ನೂ ತುಂಬಾ ನಿಧಾನವಾಗಿತ್ತು ಏಕೆಂದರೆ ಇದು ಪರಿಶೀಲಿಸಲು ಬಹಳಷ್ಟು ಅವಲಂಬನೆಗಳನ್ನು ಹೊಂದಿತ್ತು. ನಂತರ, ಪರಿಸ್ಥಿತಿಯನ್ನು ಸುಧಾರಿಸಲು, ನಾವು ರಿಮೋಟ್ ಕ್ಯಾಶಿಂಗ್ ಕಾರ್ಯವಿಧಾನವನ್ನು ಅಳವಡಿಸಿದ್ದೇವೆ. ಸ್ಥಳೀಯ ಸಂಗ್ರಹವು ಹಳೆಯದಾಗಿದೆ ಎಂದು mypy ಪತ್ತೆಮಾಡಿದರೆ, ಅದು ಕೇಂದ್ರೀಕೃತ ರೆಪೊಸಿಟರಿಯಿಂದ ಸಂಪೂರ್ಣ ಕೋಡ್‌ಬೇಸ್‌ಗಾಗಿ ಪ್ರಸ್ತುತ ಸಂಗ್ರಹ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುತ್ತದೆ. ಇದು ನಂತರ ಈ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಹೆಚ್ಚುತ್ತಿರುವ ಪರಿಶೀಲನೆಯನ್ನು ಮಾಡುತ್ತದೆ. ಇದು ಮೈಪಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೆಚ್ಚಿಸುವ ನಿಟ್ಟಿನಲ್ಲಿ ನಮಗೆ ಮತ್ತೊಂದು ದೊಡ್ಡ ಹೆಜ್ಜೆಯನ್ನು ತೆಗೆದುಕೊಂಡಿದೆ.
ಇದು ಡ್ರಾಪ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಟೈಪ್ ಚೆಕ್‌ನ ತ್ವರಿತ ಮತ್ತು ನೈಸರ್ಗಿಕ ಅಳವಡಿಕೆಯ ಅವಧಿಯಾಗಿದೆ. 2016 ರ ಅಂತ್ಯದ ವೇಳೆಗೆ, ನಾವು ಈಗಾಗಲೇ ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳೊಂದಿಗೆ ಪೈಥಾನ್ ಕೋಡ್‌ನ ಸರಿಸುಮಾರು 420000 ಸಾಲುಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಅನೇಕ ಬಳಕೆದಾರರು ಟೈಪ್ ಚೆಕ್ ಮಾಡುವ ಬಗ್ಗೆ ಉತ್ಸುಕರಾಗಿದ್ದರು. ಹೆಚ್ಚು ಹೆಚ್ಚು ಅಭಿವೃದ್ಧಿ ತಂಡಗಳು ಡ್ರಾಪ್‌ಬಾಕ್ಸ್ ಮೈಪಿಯನ್ನು ಬಳಸುತ್ತಿವೆ.
ಆಗ ಎಲ್ಲವೂ ಚೆನ್ನಾಗಿತ್ತು, ಆದರೆ ನಾವು ಇನ್ನೂ ಬಹಳಷ್ಟು ಮಾಡಬೇಕಾಗಿದೆ. ಯೋಜನೆಯ ಸಮಸ್ಯೆಯ ಪ್ರದೇಶಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಮೊದಲು ಯಾವ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಬೇಕು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಾವು ಆವರ್ತಕ ಆಂತರಿಕ ಬಳಕೆದಾರ ಸಮೀಕ್ಷೆಗಳನ್ನು ಕೈಗೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ (ಈ ಅಭ್ಯಾಸವನ್ನು ಇಂದಿಗೂ ಕಂಪನಿಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ). ಅತ್ಯಂತ ಮುಖ್ಯವಾದದ್ದು, ಅದು ಸ್ಪಷ್ಟವಾದಂತೆ, ಎರಡು ಕಾರ್ಯಗಳು. ಮೊದಲಿಗೆ, ನಮಗೆ ಕೋಡ್‌ನ ಹೆಚ್ಚಿನ ಪ್ರಕಾರದ ಕವರೇಜ್ ಅಗತ್ಯವಿದೆ, ಎರಡನೆಯದಾಗಿ, ವೇಗವಾಗಿ ಕೆಲಸ ಮಾಡಲು ನಮಗೆ mypy ಅಗತ್ಯವಿದೆ. ಮೈಪಿಯನ್ನು ವೇಗಗೊಳಿಸಲು ಮತ್ತು ಅದನ್ನು ಕಂಪನಿಯ ಯೋಜನೆಗಳಲ್ಲಿ ಅಳವಡಿಸಲು ನಮ್ಮ ಕೆಲಸವು ಇನ್ನೂ ಪೂರ್ಣಗೊಂಡಿಲ್ಲ ಎಂಬುದು ಸಂಪೂರ್ಣವಾಗಿ ಸ್ಪಷ್ಟವಾಗಿದೆ. ಈ ಎರಡು ಕಾರ್ಯಗಳ ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ಅರಿತುಕೊಂಡಿದ್ದೇವೆ, ಅವುಗಳನ್ನು ಪರಿಹರಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ.
ಹೆಚ್ಚು ಉತ್ಪಾದಕತೆ!
ಹೆಚ್ಚುತ್ತಿರುವ ತಪಾಸಣೆಗಳು mypy ಅನ್ನು ವೇಗಗೊಳಿಸಿದವು, ಆದರೆ ಉಪಕರಣವು ಇನ್ನೂ ಸಾಕಷ್ಟು ವೇಗವಾಗಿಲ್ಲ. ಅನೇಕ ಹೆಚ್ಚುತ್ತಿರುವ ತಪಾಸಣೆಗಳು ಸುಮಾರು ಒಂದು ನಿಮಿಷದವರೆಗೆ ಇದ್ದವು. ಇದಕ್ಕೆ ಕಾರಣ ಆವರ್ತಕ ಆಮದುಗಳು. ಪೈಥಾನ್‌ನಲ್ಲಿ ಬರೆಯಲಾದ ದೊಡ್ಡ ಕೋಡ್‌ಬೇಸ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿದ ಯಾರಿಗಾದರೂ ಇದು ಬಹುಶಃ ಆಶ್ಚರ್ಯವಾಗುವುದಿಲ್ಲ. ನಾವು ನೂರಾರು ಮಾಡ್ಯೂಲ್‌ಗಳ ಸೆಟ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಪ್ರತಿಯೊಂದೂ ಇತರ ಎಲ್ಲವನ್ನು ಪರೋಕ್ಷವಾಗಿ ಆಮದು ಮಾಡಿಕೊಳ್ಳುತ್ತದೆ. ಆಮದು ಲೂಪ್‌ನಲ್ಲಿರುವ ಯಾವುದೇ ಫೈಲ್ ಅನ್ನು ಬದಲಾಯಿಸಿದರೆ, mypy ಆ ಲೂಪ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಫೈಲ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬೇಕಾಗಿತ್ತು ಮತ್ತು ಆಗಾಗ್ಗೆ ಆ ಲೂಪ್‌ನಿಂದ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವ ಯಾವುದೇ ಮಾಡ್ಯೂಲ್‌ಗಳು. ಅಂತಹ ಒಂದು ಚಕ್ರವು ಕುಖ್ಯಾತ "ಅವಲಂಬನೆ ಸಿಕ್ಕು" ಆಗಿದ್ದು ಅದು ಡ್ರಾಪ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಬಹಳಷ್ಟು ತೊಂದರೆಗಳನ್ನು ಉಂಟುಮಾಡಿತು. ಒಮ್ಮೆ ಈ ರಚನೆಯು ನೂರಾರು ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದ್ದರೆ, ಅದನ್ನು ನೇರವಾಗಿ ಅಥವಾ ಪರೋಕ್ಷವಾಗಿ ಅನೇಕ ಪರೀಕ್ಷೆಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಂಡಾಗ, ಇದನ್ನು ಉತ್ಪಾದನಾ ಕೋಡ್‌ನಲ್ಲಿಯೂ ಬಳಸಲಾಯಿತು.
ವೃತ್ತಾಕಾರದ ಅವಲಂಬನೆಗಳನ್ನು "ಮುಚ್ಚುವ" ಸಾಧ್ಯತೆಯನ್ನು ನಾವು ಪರಿಗಣಿಸಿದ್ದೇವೆ, ಆದರೆ ಅದನ್ನು ಮಾಡಲು ನಮ್ಮ ಬಳಿ ಸಂಪನ್ಮೂಲಗಳು ಇರಲಿಲ್ಲ. ನಮಗೆ ಪರಿಚಯವಿಲ್ಲದ ತುಂಬಾ ಕೋಡ್ ಇತ್ತು. ಪರಿಣಾಮವಾಗಿ, ನಾವು ಪರ್ಯಾಯ ವಿಧಾನದೊಂದಿಗೆ ಬಂದಿದ್ದೇವೆ. "ಅವಲಂಬಿತ ಗೋಜಲು" ಗಳ ಉಪಸ್ಥಿತಿಯಲ್ಲಿಯೂ ಸಹ ಮೈಪಿಯನ್ನು ತ್ವರಿತವಾಗಿ ಕೆಲಸ ಮಾಡಲು ನಾವು ನಿರ್ಧರಿಸಿದ್ದೇವೆ. ನಾವು mypy ಡೀಮನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಗುರಿಯನ್ನು ಸಾಧಿಸಿದ್ದೇವೆ. ಡೀಮನ್ ಎನ್ನುವುದು ಸರ್ವರ್ ಪ್ರಕ್ರಿಯೆಯಾಗಿದ್ದು ಅದು ಎರಡು ಆಸಕ್ತಿದಾಯಕ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಮೊದಲನೆಯದಾಗಿ, ಇದು ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಪೂರ್ಣ ಕೋಡ್ಬೇಸ್ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಇದರರ್ಥ ನೀವು ಪ್ರತಿ ಬಾರಿ mypy ಅನ್ನು ರನ್ ಮಾಡಿದಾಗ, ಸಾವಿರಾರು ಆಮದು ಮಾಡಿದ ಅವಲಂಬನೆಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಕ್ಯಾಶ್ ಮಾಡಿದ ಡೇಟಾವನ್ನು ನೀವು ಲೋಡ್ ಮಾಡಬೇಕಾಗಿಲ್ಲ. ಎರಡನೆಯದಾಗಿ, ಅವರು ಎಚ್ಚರಿಕೆಯಿಂದ, ಸಣ್ಣ ರಚನಾತ್ಮಕ ಘಟಕಗಳ ಮಟ್ಟದಲ್ಲಿ, ಕಾರ್ಯಗಳು ಮತ್ತು ಇತರ ಘಟಕಗಳ ನಡುವಿನ ಅವಲಂಬನೆಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುತ್ತಾರೆ. ಉದಾಹರಣೆಗೆ, ಕಾರ್ಯ ವೇಳೆ foo ಒಂದು ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತದೆ bar, ನಂತರ ಅವಲಂಬನೆ ಇದೆ foo ರಿಂದ bar. ಫೈಲ್ ಬದಲಾದಾಗ, ಡೀಮನ್ ಮೊದಲು, ಪ್ರತ್ಯೇಕವಾಗಿ, ಬದಲಾದ ಫೈಲ್ ಅನ್ನು ಮಾತ್ರ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ. ಅದು ನಂತರ ಆ ಫೈಲ್‌ಗೆ ಬಾಹ್ಯವಾಗಿ ಗೋಚರಿಸುವ ಬದಲಾವಣೆಗಳನ್ನು ನೋಡುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಬದಲಾದ ಫಂಕ್ಷನ್ ಸಿಗ್ನೇಚರ್‌ಗಳು. ಮಾರ್ಪಡಿಸಿದ ಕಾರ್ಯವನ್ನು ನಿಜವಾಗಿ ಬಳಸುವ ಕಾರ್ಯಗಳನ್ನು ಎರಡು ಬಾರಿ ಪರಿಶೀಲಿಸಲು ಮಾತ್ರ ಡೀಮನ್ ಆಮದುಗಳ ಬಗ್ಗೆ ವಿವರವಾದ ಮಾಹಿತಿಯನ್ನು ಬಳಸುತ್ತದೆ. ವಿಶಿಷ್ಟವಾಗಿ, ಈ ವಿಧಾನದೊಂದಿಗೆ, ನೀವು ಕೆಲವೇ ಕಾರ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸಬೇಕು.
ಈ ಎಲ್ಲವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಸುಲಭವಲ್ಲ, ಏಕೆಂದರೆ ಮೂಲ mypy ಅನುಷ್ಠಾನವು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಫೈಲ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದರ ಮೇಲೆ ಹೆಚ್ಚು ಗಮನಹರಿಸಿತ್ತು. ನಾವು ಅನೇಕ ಗಡಿರೇಖೆಯ ಸಂದರ್ಭಗಳನ್ನು ಎದುರಿಸಬೇಕಾಗಿತ್ತು, ಕೋಡ್‌ನಲ್ಲಿ ಏನಾದರೂ ಬದಲಾದ ಸಂದರ್ಭಗಳಲ್ಲಿ ಪುನರಾವರ್ತಿತ ಪರಿಶೀಲನೆಗಳ ಅಗತ್ಯವಿತ್ತು. ಉದಾಹರಣೆಗೆ, ಒಂದು ವರ್ಗಕ್ಕೆ ಹೊಸ ಮೂಲ ವರ್ಗವನ್ನು ನಿಯೋಜಿಸಿದಾಗ ಇದು ಸಂಭವಿಸುತ್ತದೆ. ಒಮ್ಮೆ ನಾವು ಬಯಸಿದ್ದನ್ನು ಮಾಡಿದ ನಂತರ, ಹೆಚ್ಚಿನ ಹೆಚ್ಚುತ್ತಿರುವ ಚೆಕ್‌ಗಳ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ಕೆಲವೇ ಸೆಕೆಂಡುಗಳಿಗೆ ಕಡಿಮೆ ಮಾಡಲು ನಮಗೆ ಸಾಧ್ಯವಾಯಿತು. ಇದು ನಮಗೆ ದೊಡ್ಡ ವಿಜಯದಂತೆ ಕಂಡಿತು.
ಇನ್ನೂ ಹೆಚ್ಚಿನ ಉತ್ಪಾದಕತೆ!
ನಾನು ಮೇಲೆ ಚರ್ಚಿಸಿದ ರಿಮೋಟ್ ಕ್ಯಾಶಿಂಗ್‌ನೊಂದಿಗೆ, ಮೈಪಿ ಡೀಮನ್ ಪ್ರೋಗ್ರಾಮರ್ ಆಗಾಗ್ಗೆ ಟೈಪ್ ಚೆಕ್ ಅನ್ನು ನಡೆಸಿದಾಗ ಉದ್ಭವಿಸುವ ಸಮಸ್ಯೆಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರಿಹರಿಸುತ್ತದೆ, ಕಡಿಮೆ ಸಂಖ್ಯೆಯ ಫೈಲ್‌ಗಳಿಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಕನಿಷ್ಠ ಅನುಕೂಲಕರ ಬಳಕೆಯ ಸಂದರ್ಭದಲ್ಲಿ ಸಿಸ್ಟಮ್ ಕಾರ್ಯಕ್ಷಮತೆಯು ಇನ್ನೂ ಸೂಕ್ತವಲ್ಲ. ಮೈಪಿಯ ಕ್ಲೀನ್ ಸ್ಟಾರ್ಟಪ್ 15 ನಿಮಿಷಗಳಿಗಿಂತ ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಮತ್ತು ಇದು ನಾವು ಸಂತೋಷವಾಗಿರುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು. ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ಹೊಸ ಕೋಡ್ ಬರೆಯುವುದನ್ನು ಮುಂದುವರೆಸಿದ್ದರಿಂದ ಮತ್ತು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್‌ಗೆ ಟಿಪ್ಪಣಿಗಳನ್ನು ಸೇರಿಸುವುದರಿಂದ ಪ್ರತಿ ವಾರ ಪರಿಸ್ಥಿತಿಯು ಹದಗೆಟ್ಟಿತು. ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ನಮ್ಮ ಬಳಕೆದಾರರು ಇನ್ನೂ ಹಸಿದಿದ್ದಾರೆ, ಆದರೆ ನಾವು ಅವರನ್ನು ಅರ್ಧದಾರಿಯಲ್ಲೇ ಭೇಟಿಯಾಗಲು ಸಂತೋಷಪಟ್ಟಿದ್ದೇವೆ.
ನಾವು mypy ಬಗ್ಗೆ ಹಿಂದಿನ ವಿಚಾರಗಳಲ್ಲಿ ಒಂದಕ್ಕೆ ಹಿಂತಿರುಗಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ. ಅವುಗಳೆಂದರೆ, ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ಸಿ ಕೋಡ್ ಆಗಿ ಪರಿವರ್ತಿಸಲು. ಸೈಥಾನ್ (ಪೈಥಾನ್‌ನಲ್ಲಿ ಬರೆದ ಕೋಡ್ ಅನ್ನು ಸಿ ಕೋಡ್‌ಗೆ ಭಾಷಾಂತರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ವ್ಯವಸ್ಥೆ) ಪ್ರಯೋಗವು ನಮಗೆ ಯಾವುದೇ ಗೋಚರ ವೇಗವನ್ನು ನೀಡಲಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ನಮ್ಮದೇ ಕಂಪೈಲರ್ ಅನ್ನು ಬರೆಯುವ ಕಲ್ಪನೆಯನ್ನು ಪುನರುಜ್ಜೀವನಗೊಳಿಸಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ. mypy ಕೋಡ್ಬೇಸ್ (ಪೈಥಾನ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ) ಈಗಾಗಲೇ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ರೀತಿಯ ಟಿಪ್ಪಣಿಗಳನ್ನು ಒಳಗೊಂಡಿರುವುದರಿಂದ, ಸಿಸ್ಟಮ್ ಅನ್ನು ವೇಗಗೊಳಿಸಲು ಈ ಟಿಪ್ಪಣಿಗಳನ್ನು ಬಳಸಲು ಪ್ರಯತ್ನಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ ಎಂದು ನಾವು ಭಾವಿಸಿದ್ದೇವೆ. ಈ ಕಲ್ಪನೆಯನ್ನು ಪರೀಕ್ಷಿಸಲು ನಾನು ಶೀಘ್ರವಾಗಿ ಮೂಲಮಾದರಿಯನ್ನು ರಚಿಸಿದೆ. ಇದು ವಿವಿಧ ಮೈಕ್ರೋ-ಬೆಂಚ್‌ಮಾರ್ಕ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯಕ್ಷಮತೆಯಲ್ಲಿ 10 ಪಟ್ಟು ಹೆಚ್ಚು ಹೆಚ್ಚಳವನ್ನು ತೋರಿಸಿದೆ. ಸೈಥಾನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪೈಥಾನ್ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಸಿ ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಕಂಪೈಲ್ ಮಾಡುವುದು ಮತ್ತು ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳನ್ನು ರನ್-ಟೈಮ್ ಟೈಪ್ ಚೆಕ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸುವುದು ನಮ್ಮ ಆಲೋಚನೆಯಾಗಿತ್ತು (ಸಾಮಾನ್ಯವಾಗಿ ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳನ್ನು ರನ್-ಟೈಮ್‌ನಲ್ಲಿ ನಿರ್ಲಕ್ಷಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಟೈಪ್ ಚೆಕಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳಿಂದ ಮಾತ್ರ ಬಳಸಲಾಗುತ್ತದೆ). ಪೈಥಾನ್‌ನಿಂದ ಮೈಪಿ ಅನುಷ್ಠಾನವನ್ನು ಸ್ಥಿರವಾಗಿ ಟೈಪ್ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಭಾಷೆಗೆ ಭಾಷಾಂತರಿಸಲು ನಾವು ನಿಜವಾಗಿಯೂ ಯೋಜಿಸಿದ್ದೇವೆ, ಅದು ಪೈಥಾನ್‌ನಂತೆಯೇ ಕಾಣುತ್ತದೆ (ಮತ್ತು, ಬಹುಪಾಲು ಕೆಲಸ ಮಾಡುತ್ತದೆ). (ಈ ರೀತಿಯ ಕ್ರಾಸ್-ಲ್ಯಾಂಗ್ವೇಜ್ ವಲಸೆಯು ಮೈಪಿ ಯೋಜನೆಯ ಸಂಪ್ರದಾಯವಾಗಿದೆ. ಮೂಲ ಮೈಪಿ ಅನುಷ್ಠಾನವನ್ನು ಅಲೋರ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ, ನಂತರ ಜಾವಾ ಮತ್ತು ಪೈಥಾನ್‌ನ ಸಿಂಟ್ಯಾಕ್ಟಿಕ್ ಹೈಬ್ರಿಡ್ ಇತ್ತು).
CPython ವಿಸ್ತರಣೆ API ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುವುದು ಪ್ರಾಜೆಕ್ಟ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳದಿರಲು ಪ್ರಮುಖವಾಗಿದೆ. ಮೈಪಿಗೆ ಅಗತ್ಯವಿರುವ ವರ್ಚುವಲ್ ಯಂತ್ರ ಅಥವಾ ಯಾವುದೇ ಲೈಬ್ರರಿಗಳನ್ನು ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಾವು ಇನ್ನೂ ಸಂಪೂರ್ಣ ಪೈಥಾನ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಗೆ ಮತ್ತು ಎಲ್ಲಾ ಉಪಕರಣಗಳಿಗೆ (ಪೈಟೆಸ್ಟ್‌ನಂತಹ) ಪ್ರವೇಶವನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಇದರರ್ಥ ನಾವು ಅಭಿವೃದ್ಧಿಯ ಸಮಯದಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ಬಳಸುವುದನ್ನು ಮುಂದುವರಿಸಬಹುದು, ಕೋಡ್ ಕಂಪೈಲ್ ಮಾಡಲು ಕಾಯುವುದಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿ ಕೋಡ್ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವ ಮತ್ತು ಅದನ್ನು ಪರೀಕ್ಷಿಸುವ ಅತ್ಯಂತ ವೇಗದ ಮಾದರಿಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತದೆ. ನಾವು ಮಾತನಾಡಲು ಎರಡು ಕುರ್ಚಿಗಳ ಮೇಲೆ ಕುಳಿತುಕೊಳ್ಳುವ ಉತ್ತಮ ಕೆಲಸವನ್ನು ಮಾಡುತ್ತಿರುವಂತೆ ತೋರುತ್ತಿದೆ ಮತ್ತು ನಾವು ಅದನ್ನು ಇಷ್ಟಪಟ್ಟಿದ್ದೇವೆ.
ನಾವು mypyc ಎಂದು ಕರೆಯುವ ಕಂಪೈಲರ್ (ಇದು ಪ್ರಕಾರಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಲು ಮೈಪಿಯನ್ನು ಮುಂಭಾಗದ ತುದಿಯಾಗಿ ಬಳಸುವುದರಿಂದ) ಅತ್ಯಂತ ಯಶಸ್ವಿ ಯೋಜನೆಯಾಗಿ ಹೊರಹೊಮ್ಮಿತು. ಒಟ್ಟಾರೆಯಾಗಿ, ಕ್ಯಾಶಿಂಗ್ ಇಲ್ಲದೆಯೇ ಆಗಾಗ್ಗೆ ಮೈಪಿ ರನ್‌ಗಳಿಗಾಗಿ ನಾವು ಸರಿಸುಮಾರು 4x ವೇಗವನ್ನು ಸಾಧಿಸಿದ್ದೇವೆ. ಮೈಪಿಕ್ ಪ್ರಾಜೆಕ್ಟ್‌ನ ಕೋರ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಮೈಕೆಲ್ ಸುಲ್ಲಿವಾನ್, ಇವಾನ್ ಲೆವ್ಕಿವ್ಸ್ಕಿ, ಹಗ್ ಹಾನ್ ಮತ್ತು ನನ್ನ ಸಣ್ಣ ತಂಡವು ಸುಮಾರು 4 ಕ್ಯಾಲೆಂಡರ್ ತಿಂಗಳುಗಳನ್ನು ತೆಗೆದುಕೊಂಡಿತು. ಈ ಪ್ರಮಾಣದ ಕೆಲಸವು mypy ಅನ್ನು ಪುನಃ ಬರೆಯಲು ಬೇಕಾಗಿರುವುದಕ್ಕಿಂತ ಚಿಕ್ಕದಾಗಿದೆ, ಉದಾಹರಣೆಗೆ, C++ ಅಥವಾ Go ನಲ್ಲಿ. ಮತ್ತು ನಾವು ಯೋಜನೆಗೆ ಬೇರೆ ಭಾಷೆಯಲ್ಲಿ ಪುನಃ ಬರೆಯುವಾಗ ಮಾಡಬೇಕಾಗಿದ್ದಕ್ಕಿಂತ ಕಡಿಮೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಬೇಕಾಗಿತ್ತು. ಇತರ ಡ್ರಾಪ್‌ಬಾಕ್ಸ್ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ತಮ್ಮ ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಮತ್ತು ವೇಗಗೊಳಿಸಲು ಅದನ್ನು ಬಳಸಬಹುದಾದಂತಹ ಮಟ್ಟಕ್ಕೆ ನಾವು mypyc ಅನ್ನು ತರಬಹುದು ಎಂದು ನಾವು ಆಶಿಸಿದ್ದೇವೆ.
ಈ ಮಟ್ಟದ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸಾಧಿಸಲು, ನಾವು ಕೆಲವು ಆಸಕ್ತಿದಾಯಕ ಎಂಜಿನಿಯರಿಂಗ್ ಪರಿಹಾರಗಳನ್ನು ಅನ್ವಯಿಸಬೇಕಾಗಿತ್ತು. ಹೀಗಾಗಿ, ಕಂಪೈಲರ್ ವೇಗವಾದ, ಕಡಿಮೆ ಮಟ್ಟದ C ಸ್ಟ್ರಕ್ಟ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅನೇಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ವೇಗಗೊಳಿಸಬಹುದು ಉದಾಹರಣೆಗೆ, ಕಂಪೈಲ್ ಮಾಡಿದ ಫಂಕ್ಷನ್ ಕರೆಯನ್ನು C ಫಂಕ್ಷನ್ ಕರೆಗೆ ಅನುವಾದಿಸಲಾಗುತ್ತದೆ. ಮತ್ತು ಅಂತಹ ಕರೆಯು ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಕಾರ್ಯವನ್ನು ಕರೆಯುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು ವೇಗವಾಗಿರುತ್ತದೆ. ನಿಘಂಟಿನ ಲುಕ್‌ಅಪ್‌ಗಳಂತಹ ಕೆಲವು ಕಾರ್ಯಾಚರಣೆಗಳು, ಸಿಪಿಥಾನ್‌ನಿಂದ ಸಾಮಾನ್ಯ C-API ಕರೆಗಳನ್ನು ಬಳಸುವುದನ್ನು ಒಳಗೊಂಡಿವೆ, ಇದು ಕಂಪೈಲ್ ಮಾಡಿದಾಗ ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ವೇಗವಾಗಿರುತ್ತದೆ. ವ್ಯಾಖ್ಯಾನದಿಂದ ರಚಿಸಲಾದ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಲೋಡ್ ಅನ್ನು ತೊಡೆದುಹಾಕಲು ನಮಗೆ ಸಾಧ್ಯವಾಯಿತು, ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯ ವಿಷಯದಲ್ಲಿ ಸಣ್ಣ ಲಾಭವನ್ನು ಮಾತ್ರ ನೀಡಿತು.
ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದ "ನಿಧಾನ" ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಗುರುತಿಸಲು, ನಾವು ಕೋಡ್ ಪ್ರೊಫೈಲಿಂಗ್ ಅನ್ನು ನಿರ್ವಹಿಸಿದ್ದೇವೆ. ಈ ಡೇಟಾದೊಂದಿಗೆ ಶಸ್ತ್ರಸಜ್ಜಿತವಾಗಿ, ನಾವು mypyc ಅನ್ನು ಟ್ವೀಕ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದ್ದೇವೆ ಇದರಿಂದ ಅದು ಅಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ವೇಗವಾದ C ಕೋಡ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಅಥವಾ ವೇಗವಾದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅನುಗುಣವಾದ ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ಪುನಃ ಬರೆಯುತ್ತದೆ (ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ನಾವು ಆ ಅಥವಾ ಇತರ ಸಮಸ್ಯೆಗೆ ಸರಳವಾದ ಸಾಕಷ್ಟು ಪರಿಹಾರವನ್ನು ಹೊಂದಿಲ್ಲ) . ಕಂಪೈಲರ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅದೇ ರೂಪಾಂತರವನ್ನು ನಿರ್ವಹಿಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿ ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ಪುನಃ ಬರೆಯುವುದು ಸಮಸ್ಯೆಗೆ ಸುಲಭವಾದ ಪರಿಹಾರವಾಗಿದೆ. ದೀರ್ಘಾವಧಿಯಲ್ಲಿ, ನಾವು ಈ ಹಲವು ರೂಪಾಂತರಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಬಯಸಿದ್ದೇವೆ, ಆದರೆ ಆ ಸಮಯದಲ್ಲಿ ನಾವು ಕನಿಷ್ಟ ಪ್ರಯತ್ನದೊಂದಿಗೆ ಮೈಪಿಯನ್ನು ವೇಗಗೊಳಿಸಲು ಗಮನಹರಿಸಿದ್ದೇವೆ. ಮತ್ತು ಈ ಗುರಿಯತ್ತ ಸಾಗುವಾಗ, ನಾವು ಹಲವಾರು ಮೂಲೆಗಳನ್ನು ಕತ್ತರಿಸಿದ್ದೇವೆ.
ಮುಂದುವರೆಸಲು ...
ಆತ್ಮೀಯ ಓದುಗರು! ಮೈಪಿ ಯೋಜನೆಯ ಅಸ್ತಿತ್ವದ ಬಗ್ಗೆ ನೀವು ತಿಳಿದುಕೊಂಡಾಗ ಅದರ ಬಗ್ಗೆ ನಿಮ್ಮ ಅನಿಸಿಕೆಗಳು ಯಾವುವು?
ಮೂಲ: www.habr.com