ಪೈಥಾನ್ ಕೋಡ್‌ನ 4 ಮಿಲಿಯನ್ ಸಾಲುಗಳನ್ನು ಟೈಪ್ ಚೆಕ್ ಮಾಡುವ ಮಾರ್ಗ. ಭಾಗ 1

ಪೈಥಾನ್ ಕೋಡ್‌ನ ಪ್ರಕಾರದ ನಿಯಂತ್ರಣದೊಂದಿಗೆ ಡ್ರಾಪ್‌ಬಾಕ್ಸ್ ಹೇಗೆ ವ್ಯವಹರಿಸುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ವಸ್ತುವಿನ ಅನುವಾದದ ಮೊದಲ ಭಾಗವನ್ನು ಇಂದು ನಾವು ನಿಮ್ಮ ಗಮನಕ್ಕೆ ತರುತ್ತೇವೆ.

ಡ್ರಾಪ್‌ಬಾಕ್ಸ್ ಪೈಥಾನ್‌ನಲ್ಲಿ ಬಹಳಷ್ಟು ಬರೆಯುತ್ತದೆ. ಇದು ಬ್ಯಾಕ್ ಎಂಡ್ ಸೇವೆಗಳು ಮತ್ತು ಡೆಸ್ಕ್‌ಟಾಪ್ ಕ್ಲೈಂಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ನಾವು ಅತ್ಯಂತ ವ್ಯಾಪಕವಾಗಿ ಬಳಸುವ ಭಾಷೆಯಾಗಿದೆ. ನಾವು Go, TypeScript ಮತ್ತು Rust ಅನ್ನು ಸಹ ಬಹಳಷ್ಟು ಬಳಸುತ್ತೇವೆ, ಆದರೆ ಪೈಥಾನ್ ನಮ್ಮ ಮುಖ್ಯ ಭಾಷೆಯಾಗಿದೆ. ನಮ್ಮ ಪ್ರಮಾಣವನ್ನು ಪರಿಗಣಿಸಿ, ಮತ್ತು ನಾವು ಪೈಥಾನ್ ಕೋಡ್‌ನ ಲಕ್ಷಾಂತರ ಸಾಲುಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ, ಅಂತಹ ಕೋಡ್‌ನ ಡೈನಾಮಿಕ್ ಟೈಪಿಂಗ್ ಅನಗತ್ಯವಾಗಿ ಅದರ ತಿಳುವಳಿಕೆಯನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸಿತು ಮತ್ತು ಕಾರ್ಮಿಕ ಉತ್ಪಾದಕತೆಯನ್ನು ಗಂಭೀರವಾಗಿ ಪರಿಣಾಮ ಬೀರಲು ಪ್ರಾರಂಭಿಸಿತು. ಈ ಸಮಸ್ಯೆಯನ್ನು ತಗ್ಗಿಸಲು, ನಾವು mypy ಬಳಸಿಕೊಂಡು ಸ್ಥಿರ ರೀತಿಯ ಪರಿಶೀಲನೆಗೆ ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಕ್ರಮೇಣವಾಗಿ ಪರಿವರ್ತಿಸಲು ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ. ಇದು ಬಹುಶಃ ಪೈಥಾನ್‌ಗಾಗಿ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಸ್ವತಂತ್ರ ಪ್ರಕಾರದ ತಪಾಸಣೆ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ. Mypy ಒಂದು ಮುಕ್ತ ಮೂಲ ಯೋಜನೆಯಾಗಿದೆ, ಅದರ ಮುಖ್ಯ ಅಭಿವರ್ಧಕರು ಡ್ರಾಪ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ.

ಈ ಪ್ರಮಾಣದಲ್ಲಿ ಪೈಥಾನ್ ಕೋಡ್‌ನಲ್ಲಿ ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪ್ ಚೆಕ್ ಅನ್ನು ಅಳವಡಿಸಿದ ಮೊದಲ ಕಂಪನಿಗಳಲ್ಲಿ ಡ್ರಾಪ್‌ಬಾಕ್ಸ್ ಒಂದಾಗಿದೆ. ಈ ದಿನಗಳಲ್ಲಿ ಸಾವಿರಾರು ಯೋಜನೆಗಳಲ್ಲಿ Mypy ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಉಪಕರಣವು ಲೆಕ್ಕವಿಲ್ಲದಷ್ಟು ಬಾರಿ, ಅವರು ಹೇಳಿದಂತೆ, "ಯುದ್ಧದಲ್ಲಿ ಪರೀಕ್ಷಿಸಲಾಗಿದೆ." ನಾವು ಈಗ ಇರುವ ಸ್ಥಿತಿಗೆ ತಲುಪಲು ಬಹಳ ದೂರ ಬಂದಿದ್ದೇವೆ. ದಾರಿಯುದ್ದಕ್ಕೂ, ಅನೇಕ ವಿಫಲ ಕಾರ್ಯಗಳು ಮತ್ತು ವಿಫಲವಾದ ಪ್ರಯೋಗಗಳು ಇದ್ದವು. ಪೈಥಾನ್‌ನಲ್ಲಿ ಬರೆಯುವ ಅಸಂಖ್ಯಾತ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಟೈಪ್ ಚೆಕ್ ಮತ್ತು ಟೈಪ್ ಸುಳಿವು ಸಾಮಾನ್ಯವಾಗಿರುವ ಇಂದಿನವರೆಗೆ, ನನ್ನ ಸಂಶೋಧನಾ ಯೋಜನೆಯ ಭಾಗವಾಗಿ ಅದರ ಕಲ್ಲಿನ ಆರಂಭದಿಂದ ಪೈಥಾನ್‌ನಲ್ಲಿ ಸ್ಥಿರ ಪ್ರಕಾರದ ಪರಿಶೀಲನೆಯ ಇತಿಹಾಸವನ್ನು ಈ ಪೋಸ್ಟ್ ಒಳಗೊಂಡಿದೆ. ಈ ಕಾರ್ಯವಿಧಾನಗಳು ಈಗ IDE ಗಳು ಮತ್ತು ಕೋಡ್ ವಿಶ್ಲೇಷಕಗಳಂತಹ ಅನೇಕ ಸಾಧನಗಳಿಂದ ಬೆಂಬಲಿತವಾಗಿದೆ.

→ ಎರಡನೇ ಭಾಗವನ್ನು ಓದಿ

ಟೈಪ್ ಚೆಕ್ ಏಕೆ ಅಗತ್ಯ?

ನೀವು ಎಂದಾದರೂ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಟೈಪ್ ಮಾಡಲಾದ ಪೈಥಾನ್ ಅನ್ನು ಬಳಸಿದ್ದರೆ, ಇತ್ತೀಚೆಗೆ ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪಿಂಗ್ ಮತ್ತು ಮೈಪಿಯ ಬಗ್ಗೆ ಏಕೆ ಇಂತಹ ಗಡಿಬಿಡಿಯಾಗಿದೆ ಎಂಬ ಬಗ್ಗೆ ನಿಮಗೆ ಸ್ವಲ್ಪ ಗೊಂದಲವಿರಬಹುದು. ಅಥವಾ ನೀವು ಪೈಥಾನ್ ಅನ್ನು ಅದರ ಡೈನಾಮಿಕ್ ಟೈಪಿಂಗ್‌ನಿಂದ ನಿಖರವಾಗಿ ಇಷ್ಟಪಡುತ್ತೀರಿ ಮತ್ತು ಏನಾಗುತ್ತಿದೆ ಎಂಬುದು ನಿಮ್ಮನ್ನು ಅಸಮಾಧಾನಗೊಳಿಸುತ್ತದೆ. ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪಿಂಗ್‌ನ ಮೌಲ್ಯಕ್ಕೆ ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ಪರಿಹಾರಗಳ ಪ್ರಮಾಣ: ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ದೊಡ್ಡದಾದಷ್ಟೂ ನೀವು ಸ್ಥಿರ ಟೈಪಿಂಗ್‌ನತ್ತ ಹೆಚ್ಚು ಒಲವು ತೋರುತ್ತೀರಿ ಮತ್ತು ಕೊನೆಯಲ್ಲಿ, ನಿಮಗೆ ನಿಜವಾಗಿಯೂ ಅದು ಬೇಕಾಗುತ್ತದೆ.

ಒಂದು ನಿರ್ದಿಷ್ಟ ಯೋಜನೆಯು ಹತ್ತಾರು ಸಾವಿರ ಸಾಲುಗಳ ಗಾತ್ರವನ್ನು ತಲುಪಿದೆ ಎಂದು ಭಾವಿಸೋಣ ಮತ್ತು ಹಲವಾರು ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಅದರಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದಾರೆ ಎಂದು ಅದು ಬದಲಾಯಿತು. ಇದೇ ರೀತಿಯ ಯೋಜನೆಯನ್ನು ನೋಡುವಾಗ, ನಮ್ಮ ಅನುಭವದ ಆಧಾರದ ಮೇಲೆ, ಅದರ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಡೆವಲಪರ್‌ಗಳನ್ನು ಉತ್ಪಾದಕವಾಗಿಡಲು ಕೀಲಿಯಾಗಿದೆ ಎಂದು ನಾವು ಹೇಳಬಹುದು. ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳಿಲ್ಲದೆ, ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಕಷ್ಟವಾಗಬಹುದು, ಉದಾಹರಣೆಗೆ, ಒಂದು ಫಂಕ್ಷನ್‌ಗೆ ಯಾವ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ರವಾನಿಸಬೇಕು ಅಥವಾ ಯಾವ ಪ್ರಕಾರದ ಫಂಕ್ಷನ್ ಹಿಂತಿರುಗಬಹುದು. ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳನ್ನು ಬಳಸದೆಯೇ ಉತ್ತರಿಸಲು ಸಾಮಾನ್ಯವಾಗಿ ಕಷ್ಟಕರವಾದ ವಿಶಿಷ್ಟ ಪ್ರಶ್ನೆಗಳು ಇಲ್ಲಿವೆ:

• ಈ ಕಾರ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಬಹುದೇ? None?
• ಈ ವಾದ ಏನಾಗಿರಬೇಕು? items?
• ಗುಣಲಕ್ಷಣದ ಪ್ರಕಾರ ಯಾವುದು id: int ಓ ಹೌದಾ, ಹೌದಾ, str, ಅಥವಾ ಬಹುಶಃ ಕೆಲವು ಕಸ್ಟಮ್ ಪ್ರಕಾರ?
• ಈ ವಾದವು ಪಟ್ಟಿಯಾಗಬೇಕೇ? ಅದಕ್ಕೆ ಟ್ಯೂಪಲ್ ರವಾನಿಸಲು ಸಾಧ್ಯವೇ?

ನೀವು ಈ ಕೆಳಗಿನ ಟೈಪ್-ಟಿಪ್ಪಣಿ ಮಾಡಿದ ಕೋಡ್ ತುಣುಕನ್ನು ನೋಡಿದರೆ ಮತ್ತು ಇದೇ ರೀತಿಯ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ಇದು ಸರಳವಾದ ಕಾರ್ಯವಾಗಿದೆ:

class Resource:
    id: bytes
    ...
    def read_metadata(self, 
                      items: Sequence[str]) -> Dict[str, MetadataItem]:
        ...

• read_metadata ಹಿಂತಿರುಗುವುದಿಲ್ಲ None, ರಿಟರ್ನ್ ಟೈಪ್ ಇಲ್ಲದಿರುವುದರಿಂದ Optional[…].
• ವಾದ items ಸಾಲುಗಳ ಅನುಕ್ರಮವಾಗಿದೆ. ಇದನ್ನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಪುನರಾವರ್ತಿಸಲಾಗುವುದಿಲ್ಲ.
• ಗುಣಲಕ್ಷಣ id ಬೈಟ್‌ಗಳ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ.

ಆದರ್ಶ ಜಗತ್ತಿನಲ್ಲಿ, ಅಂತಹ ಎಲ್ಲಾ ಸೂಕ್ಷ್ಮತೆಗಳನ್ನು ಅಂತರ್ನಿರ್ಮಿತ ದಾಖಲಾತಿಯಲ್ಲಿ (ಡಾಕ್ಸ್ಟ್ರಿಂಗ್) ವಿವರಿಸಲಾಗುವುದು ಎಂದು ಒಬ್ಬರು ನಿರೀಕ್ಷಿಸಬಹುದು. ಆದರೆ ನೀವು ಕೆಲಸ ಮಾಡಬೇಕಾದ ಕೋಡ್‌ನಲ್ಲಿ ಅಂತಹ ದಸ್ತಾವೇಜನ್ನು ಹೆಚ್ಚಾಗಿ ಗಮನಿಸಲಾಗುವುದಿಲ್ಲ ಎಂಬುದಕ್ಕೆ ಅನುಭವವು ಬಹಳಷ್ಟು ಉದಾಹರಣೆಗಳನ್ನು ನೀಡುತ್ತದೆ. ಅಂತಹ ದಸ್ತಾವೇಜನ್ನು ಕೋಡ್‌ನಲ್ಲಿದ್ದರೂ ಸಹ, ಅದರ ಸಂಪೂರ್ಣ ಸರಿಯಾಗಿರುವುದನ್ನು ಒಬ್ಬರು ಎಣಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಈ ದಸ್ತಾವೇಜನ್ನು ಅಸ್ಪಷ್ಟವಾಗಿರಬಹುದು, ತಪ್ಪಾಗಿರಬಹುದು ಮತ್ತು ತಪ್ಪುಗ್ರಹಿಕೆಗೆ ಮುಕ್ತವಾಗಿರಬಹುದು. ದೊಡ್ಡ ತಂಡಗಳು ಅಥವಾ ದೊಡ್ಡ ಯೋಜನೆಗಳಲ್ಲಿ, ಈ ಸಮಸ್ಯೆಯು ಅತ್ಯಂತ ತೀವ್ರವಾಗಬಹುದು.

ಪ್ರಾಜೆಕ್ಟ್‌ಗಳ ಆರಂಭಿಕ ಅಥವಾ ಮಧ್ಯಂತರ ಹಂತಗಳಲ್ಲಿ ಪೈಥಾನ್ ಉತ್ತಮವಾಗಿದ್ದರೂ, ಕೆಲವು ಹಂತದಲ್ಲಿ ಯಶಸ್ವಿ ಯೋಜನೆಗಳು ಮತ್ತು ಪೈಥಾನ್ ಬಳಸುವ ಕಂಪನಿಗಳು ಪ್ರಮುಖ ಪ್ರಶ್ನೆಯನ್ನು ಎದುರಿಸಬಹುದು: “ನಾವು ಎಲ್ಲವನ್ನೂ ಸ್ಥಿರವಾಗಿ ಟೈಪ್ ಮಾಡಿದ ಭಾಷೆಯಲ್ಲಿ ಪುನಃ ಬರೆಯಬೇಕೇ?”.

mypy ನಂತಹ ಟೈಪ್ ಚೆಕ್ ಮಾಡುವ ವ್ಯವಸ್ಥೆಗಳು ಡೆವಲಪರ್‌ಗೆ ಪ್ರಕಾರಗಳನ್ನು ವಿವರಿಸಲು ಔಪಚಾರಿಕ ಭಾಷೆಯನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಮೇಲಿನ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತವೆ ಮತ್ತು ಆ ಪ್ರಕಾರದ ಘೋಷಣೆಗಳು ಪ್ರೋಗ್ರಾಂ ಅನುಷ್ಠಾನಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುತ್ತವೆ ಎಂದು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ (ಮತ್ತು, ಐಚ್ಛಿಕವಾಗಿ, ಅವುಗಳ ಅಸ್ತಿತ್ವವನ್ನು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ). ಸಾಮಾನ್ಯವಾಗಿ, ಈ ವ್ಯವಸ್ಥೆಗಳು ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಶೀಲಿಸಿದ ದಾಖಲಾತಿಗಳಂತಹವುಗಳನ್ನು ನಮ್ಮ ಇತ್ಯರ್ಥಕ್ಕೆ ಇರಿಸುತ್ತವೆ ಎಂದು ನಾವು ಹೇಳಬಹುದು.

ಅಂತಹ ವ್ಯವಸ್ಥೆಗಳ ಬಳಕೆಯು ಇತರ ಪ್ರಯೋಜನಗಳನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ಅವು ಈಗಾಗಲೇ ಸಂಪೂರ್ಣವಾಗಿ ಕ್ಷುಲ್ಲಕವಲ್ಲ:

• ಟೈಪ್ ಚೆಕಿಂಗ್ ಸಿಸ್ಟಮ್ ಕೆಲವು ಸಣ್ಣ (ಮತ್ತು ಅಷ್ಟು ಚಿಕ್ಕದಲ್ಲ) ದೋಷಗಳನ್ನು ಪತ್ತೆ ಮಾಡುತ್ತದೆ. ಮೌಲ್ಯವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಅವರು ಮರೆತಾಗ ಒಂದು ವಿಶಿಷ್ಟ ಉದಾಹರಣೆಯಾಗಿದೆ None ಅಥವಾ ಕೆಲವು ಇತರ ವಿಶೇಷ ಸ್ಥಿತಿ.
• ಕೋಡ್ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಅನ್ನು ಹೆಚ್ಚು ಸರಳಗೊಳಿಸಲಾಗಿದೆ ಏಕೆಂದರೆ ಯಾವ ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸಬೇಕು ಎಂಬುದರ ಕುರಿತು ಟೈಪ್ ಚೆಕ್ ಸಿಸ್ಟಮ್ ಹೆಚ್ಚಾಗಿ ನಿಖರವಾಗಿರುತ್ತದೆ. ಅದೇ ಸಮಯದಲ್ಲಿ, ಪರೀಕ್ಷೆಗಳೊಂದಿಗೆ 100% ಕೋಡ್ ಕವರೇಜ್ಗಾಗಿ ನಾವು ಆಶಿಸಬೇಕಾಗಿಲ್ಲ, ಇದು ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಕಾರ್ಯಸಾಧ್ಯವಲ್ಲ. ಸಮಸ್ಯೆಯ ಕಾರಣವನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಾವು ಸ್ಟಾಕ್ ಟ್ರೇಸ್ನ ಆಳವನ್ನು ಪರಿಶೀಲಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.
• ದೊಡ್ಡ ಯೋಜನೆಗಳಲ್ಲಿಯೂ ಸಹ, mypy ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು ಸೆಕೆಂಡಿನ ಭಾಗದಲ್ಲಿ ಪೂರ್ಣ ಪ್ರಕಾರದ ಪರಿಶೀಲನೆಯನ್ನು ಮಾಡಬಹುದು. ಮತ್ತು ಪರೀಕ್ಷೆಗಳ ಮರಣದಂಡನೆಯು ಸಾಮಾನ್ಯವಾಗಿ ಹತ್ತಾರು ಸೆಕೆಂಡುಗಳು ಅಥವಾ ನಿಮಿಷಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಟೈಪ್ ಚೆಕಿಂಗ್ ಸಿಸ್ಟಮ್ ಪ್ರೋಗ್ರಾಮರ್‌ಗೆ ತ್ವರಿತ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನೀಡುತ್ತದೆ ಮತ್ತು ಅವನ ಕೆಲಸವನ್ನು ವೇಗವಾಗಿ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ. ಕೋಡ್ ಪರೀಕ್ಷೆಯ ಫಲಿತಾಂಶಗಳನ್ನು ವೇಗವಾಗಿ ಪಡೆಯಲು ನೈಜ ಘಟಕಗಳನ್ನು ಅಣಕುಗಳು ಮತ್ತು ಪ್ಯಾಚ್‌ಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸುವ ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅವನು ಇನ್ನು ಮುಂದೆ ದುರ್ಬಲ ಮತ್ತು ಕಠಿಣವಾಗಿ ಬರೆಯುವ ಅಗತ್ಯವಿಲ್ಲ.

PyCharm ಅಥವಾ ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೋ ಕೋಡ್‌ನಂತಹ IDE ಗಳು ಮತ್ತು ಸಂಪಾದಕರು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಕೋಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ, ದೋಷ ಹೈಲೈಟ್ ಮಾಡುವುದು ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಭಾಷಾ ರಚನೆಗಳಿಗೆ ಬೆಂಬಲವನ್ನು ಒದಗಿಸಲು ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳ ಶಕ್ತಿಯನ್ನು ಬಳಸುತ್ತಾರೆ. ಮತ್ತು ಇವುಗಳು ಟೈಪಿಂಗ್‌ನ ಕೆಲವು ಪ್ರಯೋಜನಗಳಾಗಿವೆ. ಕೆಲವು ಪ್ರೋಗ್ರಾಮರ್ಗಳಿಗೆ, ಟೈಪಿಂಗ್ ಪರವಾಗಿ ಇದೆಲ್ಲವೂ ಮುಖ್ಯ ವಾದವಾಗಿದೆ. ಇದು ಅನುಷ್ಠಾನದ ನಂತರ ತಕ್ಷಣವೇ ಲಾಭದಾಯಕವಾಗಿದೆ. ಪ್ರಕಾರಗಳ ಈ ಬಳಕೆಯ ಪ್ರಕರಣಕ್ಕೆ mypy ನಂತಹ ಪ್ರತ್ಯೇಕ ಪ್ರಕಾರದ ತಪಾಸಣೆ ವ್ಯವಸ್ಥೆಯ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ, ಆದಾಗ್ಯೂ mypy ಪ್ರಕಾರದ ಟಿಪ್ಪಣಿಗಳನ್ನು ಕೋಡ್‌ಗೆ ಅನುಗುಣವಾಗಿ ಇರಿಸಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಬೇಕು.

ಮೈಪಿಯ ಹಿನ್ನೆಲೆ

ನಾನು ಡ್ರಾಪ್‌ಬಾಕ್ಸ್‌ಗೆ ಸೇರುವ ಕೆಲವು ವರ್ಷಗಳ ಮೊದಲು ಮೈಪಿಯ ಇತಿಹಾಸವು ಯುಕೆಯಲ್ಲಿ, ಕೇಂಬ್ರಿಡ್ಜ್‌ನಲ್ಲಿ ಪ್ರಾರಂಭವಾಯಿತು. ನನ್ನ ಡಾಕ್ಟರೇಟ್ ಸಂಶೋಧನೆಯ ಭಾಗವಾಗಿ, ಸ್ಥಿರವಾಗಿ ಟೈಪ್ ಮಾಡಿದ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ಭಾಷೆಗಳ ಏಕೀಕರಣದಲ್ಲಿ ನಾನು ತೊಡಗಿಸಿಕೊಂಡಿದ್ದೇನೆ. ಜೆರೆಮಿ ಸಿಯೆಕ್ ಮತ್ತು ವಾಲಿದ್ ತಾಹಾ ಅವರ ಇನ್‌ಕ್ರಿಮೆಂಟಲ್ ಟೈಪಿಂಗ್ ಕುರಿತ ಲೇಖನ ಮತ್ತು ಟೈಪ್ಡ್ ರಾಕೆಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ನಿಂದ ನಾನು ಸ್ಫೂರ್ತಿ ಪಡೆದಿದ್ದೇನೆ. ನಾನು ವಿವಿಧ ಯೋಜನೆಗಳಿಗೆ ಒಂದೇ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯನ್ನು ಬಳಸುವ ಮಾರ್ಗಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಪ್ರಯತ್ನಿಸಿದೆ - ಸಣ್ಣ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿಂದ ಹಿಡಿದು ಲಕ್ಷಾಂತರ ಸಾಲುಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಕೋಡ್ ಬೇಸ್‌ಗಳವರೆಗೆ. ಅದೇ ಸಮಯದಲ್ಲಿ, ಯಾವುದೇ ಪ್ರಮಾಣದ ಯೋಜನೆಯಲ್ಲಿ ಒಬ್ಬರು ತುಂಬಾ ದೊಡ್ಡ ರಾಜಿ ಮಾಡಿಕೊಳ್ಳಬೇಕಾಗಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಾನು ಬಯಸುತ್ತೇನೆ. ಈ ಎಲ್ಲದರ ಪ್ರಮುಖ ಭಾಗವೆಂದರೆ ಟೈಪ್ ಮಾಡದ ಮೂಲಮಾದರಿ ಯೋಜನೆಯಿಂದ ಸಮಗ್ರವಾಗಿ ಪರೀಕ್ಷಿಸಿದ ಸ್ಥಿರವಾಗಿ ಟೈಪ್ ಮಾಡಿದ ಸಿದ್ಧಪಡಿಸಿದ ಉತ್ಪನ್ನಕ್ಕೆ ಕ್ರಮೇಣ ಚಲಿಸುವ ಕಲ್ಪನೆ. ಈ ದಿನಗಳಲ್ಲಿ, ಈ ವಿಚಾರಗಳನ್ನು ಬಹುಮಟ್ಟಿಗೆ ಲಘುವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ, ಆದರೆ 2010 ರಲ್ಲಿ ಇದು ಇನ್ನೂ ಸಕ್ರಿಯವಾಗಿ ಅನ್ವೇಷಿಸಲ್ಪಡುವ ಸಮಸ್ಯೆಯಾಗಿದೆ.

ಟೈಪ್ ಚೆಕಿಂಗ್‌ನಲ್ಲಿ ನನ್ನ ಮೂಲ ಕೆಲಸವು ಪೈಥಾನ್ ಅನ್ನು ಗುರಿಯಾಗಿಸಿಕೊಂಡಿಲ್ಲ. ಬದಲಿಗೆ, ನಾನು ಸಣ್ಣ "ಮನೆಯಲ್ಲಿ" ಭಾಷೆಯನ್ನು ಬಳಸಿದ್ದೇನೆ ಅಲೋರ್. ನಾವು ಏನು ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ (ಪ್ರಕಾರದ ಟಿಪ್ಪಣಿಗಳು ಇಲ್ಲಿ ಐಚ್ಛಿಕವಾಗಿರುತ್ತವೆ):

def Fib(n as Int) as Int
  if n <= 1
    return n
  else
    return Fib(n - 1) + Fib(n - 2)
  end
end

ಸರಳೀಕೃತ ಸ್ಥಳೀಯ ಭಾಷೆಯನ್ನು ಬಳಸುವುದು ವೈಜ್ಞಾನಿಕ ಸಂಶೋಧನೆಯಲ್ಲಿ ಬಳಸುವ ಸಾಮಾನ್ಯ ವಿಧಾನವಾಗಿದೆ. ಇದು ಹಾಗಲ್ಲ, ಏಕೆಂದರೆ ಇದು ತ್ವರಿತವಾಗಿ ಪ್ರಯೋಗಗಳನ್ನು ನಡೆಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಮತ್ತು ಅಧ್ಯಯನದೊಂದಿಗೆ ಯಾವುದೇ ಸಂಬಂಧವಿಲ್ಲ ಎಂಬುದನ್ನು ಸುಲಭವಾಗಿ ನಿರ್ಲಕ್ಷಿಸಬಹುದು. ನೈಜ-ಪ್ರಪಂಚದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಸಂಕೀರ್ಣವಾದ ಅನುಷ್ಠಾನಗಳೊಂದಿಗೆ ದೊಡ್ಡ-ಪ್ರಮಾಣದ ವಿದ್ಯಮಾನಗಳಾಗಿವೆ ಮತ್ತು ಇದು ಪ್ರಯೋಗವನ್ನು ನಿಧಾನಗೊಳಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಸರಳೀಕೃತ ಭಾಷೆಯ ಆಧಾರದ ಮೇಲೆ ಯಾವುದೇ ಫಲಿತಾಂಶಗಳು ಸ್ವಲ್ಪ ಅನುಮಾನಾಸ್ಪದವಾಗಿ ಕಾಣುತ್ತವೆ, ಏಕೆಂದರೆ ಈ ಫಲಿತಾಂಶಗಳನ್ನು ಪಡೆಯುವಲ್ಲಿ ಸಂಶೋಧಕರು ಭಾಷೆಗಳ ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಗೆ ಪ್ರಮುಖವಾದ ಪರಿಗಣನೆಗಳನ್ನು ತ್ಯಾಗ ಮಾಡಿರಬಹುದು.

ಅಲೋರ್‌ಗಾಗಿ ನನ್ನ ಪ್ರಕಾರದ ಪರೀಕ್ಷಕವು ತುಂಬಾ ಭರವಸೆಯಿತ್ತು, ಆದರೆ ನೈಜ ಕೋಡ್‌ನೊಂದಿಗೆ ಪ್ರಯೋಗ ಮಾಡುವ ಮೂಲಕ ನಾನು ಅದನ್ನು ಪರೀಕ್ಷಿಸಲು ಬಯಸುತ್ತೇನೆ, ಇದು ಅಲೋರ್‌ನಲ್ಲಿ ಬರೆಯಲ್ಪಟ್ಟಿಲ್ಲ ಎಂದು ನೀವು ಹೇಳಬಹುದು. ನನ್ನ ಅದೃಷ್ಟವಶಾತ್, ಅಲೋರ್ ಭಾಷೆಯು ಹೆಚ್ಚಾಗಿ ಪೈಥಾನ್‌ನಂತೆಯೇ ಅದೇ ಆಲೋಚನೆಗಳನ್ನು ಆಧರಿಸಿದೆ. ಪೈಥಾನ್‌ನ ಸಿಂಟ್ಯಾಕ್ಸ್ ಮತ್ತು ಸೆಮ್ಯಾಂಟಿಕ್ಸ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಟೈಪ್‌ಚೆಕರ್ ಅನ್ನು ರೀಮೇಕ್ ಮಾಡಲು ಸಾಕಷ್ಟು ಸುಲಭವಾಗಿದೆ. ಓಪನ್ ಸೋರ್ಸ್ ಪೈಥಾನ್ ಕೋಡ್‌ನಲ್ಲಿ ಟೈಪ್ ಚೆಕ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಲು ಇದು ನಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಟ್ಟಿತು. ಜೊತೆಗೆ, ಅಲೋರ್‌ನಲ್ಲಿ ಬರೆದಿರುವ ಕೋಡ್ ಅನ್ನು ಪೈಥಾನ್ ಕೋಡ್‌ಗೆ ಪರಿವರ್ತಿಸಲು ನಾನು ಟ್ರಾನ್ಸ್‌ಪೈಲರ್ ಅನ್ನು ಬರೆದಿದ್ದೇನೆ ಮತ್ತು ಅದನ್ನು ನನ್ನ ಟೈಪ್‌ಚೆಕರ್ ಕೋಡ್ ಅನ್ನು ಭಾಷಾಂತರಿಸಲು ಬಳಸಿದ್ದೇನೆ. ಈಗ ನಾನು ಪೈಥಾನ್‌ನಲ್ಲಿ ಬರೆಯಲಾದ ಟೈಪ್ ಚೆಕಿಂಗ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಹೊಂದಿದ್ದೇನೆ ಅದು ಪೈಥಾನ್‌ನ ಉಪವಿಭಾಗವನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಆ ಭಾಷೆಯ ಕೆಲವು ರೀತಿಯ! (ಅಲೋರ್‌ಗೆ ಅರ್ಥಪೂರ್ಣವಾದ ಕೆಲವು ವಾಸ್ತುಶಿಲ್ಪದ ನಿರ್ಧಾರಗಳು ಪೈಥಾನ್‌ಗೆ ಸರಿಯಾಗಿ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ, ಮತ್ತು ಇದು ಮೈಪಿ ಕೋಡ್‌ಬೇಸ್‌ನ ಭಾಗಗಳಲ್ಲಿ ಇನ್ನೂ ಗಮನಾರ್ಹವಾಗಿದೆ.)

ವಾಸ್ತವವಾಗಿ, ನನ್ನ ಪ್ರಕಾರದ ಸಿಸ್ಟಮ್‌ನಿಂದ ಬೆಂಬಲಿತವಾದ ಭಾಷೆಯನ್ನು ಈ ಹಂತದಲ್ಲಿ ಪೈಥಾನ್ ಎಂದು ಕರೆಯಲಾಗಲಿಲ್ಲ: ಪೈಥಾನ್ 3 ಪ್ರಕಾರದ ಟಿಪ್ಪಣಿ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನ ಕೆಲವು ಮಿತಿಗಳಿಂದಾಗಿ ಇದು ಪೈಥಾನ್‌ನ ರೂಪಾಂತರವಾಗಿದೆ.

ಇದು ಜಾವಾ ಮತ್ತು ಪೈಥಾನ್ ಮಿಶ್ರಣದಂತೆ ಕಾಣುತ್ತದೆ:

int fib(int n):
    if n <= 1:
        return n
    else:
        return fib(n - 1) + fib(n - 2)

ಈ ರೀತಿಯ ಪೈಥಾನ್ ಅನ್ನು C ಅಥವಾ ಬಹುಶಃ JVM ಬೈಟ್‌ಕೋಡ್‌ಗೆ ಕಂಪೈಲ್ ಮಾಡುವ ಮೂಲಕ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳನ್ನು ಬಳಸುವುದು ಆ ಸಮಯದಲ್ಲಿ ನನ್ನ ಆಲೋಚನೆಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ನಾನು ಕಂಪೈಲರ್ ಮೂಲಮಾದರಿಯನ್ನು ಬರೆಯುವ ಹಂತಕ್ಕೆ ಬಂದಿದ್ದೇನೆ, ಆದರೆ ನಾನು ಈ ಆಲೋಚನೆಯನ್ನು ತ್ಯಜಿಸಿದೆ, ಏಕೆಂದರೆ ಟೈಪ್ ಚೆಕ್ ಸ್ವತಃ ಸಾಕಷ್ಟು ಉಪಯುಕ್ತವಾಗಿದೆ.

ನನ್ನ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಸಾಂಟಾ ಕ್ಲಾರಾದಲ್ಲಿ PyCon 2013 ರಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸಲು ನಾನು ಕೊನೆಗೊಂಡಿದ್ದೇನೆ. ಜೀವನಕ್ಕಾಗಿ ಪರೋಪಕಾರಿ ಪೈಥಾನ್ ಸರ್ವಾಧಿಕಾರಿ ಗೈಡೋ ವ್ಯಾನ್ ರೋಸಮ್ ಅವರೊಂದಿಗೆ ನಾನು ಈ ಬಗ್ಗೆ ಮಾತನಾಡಿದೆ. ನನ್ನ ಸ್ವಂತ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಿಡಲು ಮತ್ತು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಪೈಥಾನ್ 3 ಸಿಂಟ್ಯಾಕ್ಸ್‌ನೊಂದಿಗೆ ಅಂಟಿಕೊಳ್ಳುವಂತೆ ಅವರು ನನಗೆ ಮನವರಿಕೆ ಮಾಡಿದರು. ಪೈಥಾನ್ 3 ಕಾರ್ಯ ಟಿಪ್ಪಣಿಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನನ್ನ ಉದಾಹರಣೆಯನ್ನು ಕೆಳಗೆ ತೋರಿಸಿರುವಂತೆ ಪುನಃ ಬರೆಯಬಹುದು, ಇದು ಸಾಮಾನ್ಯ ಪೈಥಾನ್ ಪ್ರೋಗ್ರಾಂಗೆ ಕಾರಣವಾಗುತ್ತದೆ:

def fib(n: int) -> int:
    if n <= 1:
        return n
    else:
        return fib(n - 1) + fib(n - 2)

ನಾನು ಕೆಲವು ಹೊಂದಾಣಿಕೆಗಳನ್ನು ಮಾಡಬೇಕಾಗಿತ್ತು (ಮೊದಲನೆಯದಾಗಿ, ಈ ಕಾರಣಕ್ಕಾಗಿ ನಾನು ನನ್ನ ಸ್ವಂತ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಕಂಡುಹಿಡಿದಿದ್ದೇನೆ ಎಂದು ನಾನು ಗಮನಿಸಲು ಬಯಸುತ್ತೇನೆ). ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಆ ಸಮಯದಲ್ಲಿ ಭಾಷೆಯ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯಾದ ಪೈಥಾನ್ 3.3 ವೇರಿಯಬಲ್ ಟಿಪ್ಪಣಿಗಳನ್ನು ಬೆಂಬಲಿಸಲಿಲ್ಲ. ಅಂತಹ ಟಿಪ್ಪಣಿಗಳ ವಾಕ್ಯರಚನೆಯ ವಿನ್ಯಾಸಕ್ಕಾಗಿ ನಾನು ಇ-ಮೇಲ್ ಮೂಲಕ ಗೈಡೋ ಅವರೊಂದಿಗೆ ಚರ್ಚಿಸಿದೆ. ವೇರಿಯೇಬಲ್‌ಗಳಿಗೆ ಟೈಪ್ ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಬಳಸಲು ನಾವು ನಿರ್ಧರಿಸಿದ್ದೇವೆ. ಇದು ಉದ್ದೇಶಿತ ಉದ್ದೇಶವನ್ನು ಪೂರೈಸಿತು, ಆದರೆ ಸ್ವಲ್ಪ ತೊಡಕಿನದ್ದಾಗಿತ್ತು (ಪೈಥಾನ್ 3.6 ನಮಗೆ ಉತ್ತಮವಾದ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ನೀಡಿತು):

products = []  # type: List[str]  # Eww

ಟೈಪ್ ಕಾಮೆಂಟ್‌ಗಳು ಪೈಥಾನ್ 2 ಅನ್ನು ಬೆಂಬಲಿಸಲು ಸೂಕ್ತವಾಗಿ ಬಂದವು, ಇದು ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳಿಗೆ ಅಂತರ್ನಿರ್ಮಿತ ಬೆಂಬಲವನ್ನು ಹೊಂದಿಲ್ಲ:

f fib(n):
    # type: (int) -> int
    if n <= 1:
        return n
    else:
        return fib(n - 1) + fib(n - 2)

ಈ (ಮತ್ತು ಇತರ) ಟ್ರೇಡ್-ಆಫ್‌ಗಳು ನಿಜವಾಗಿಯೂ ಮುಖ್ಯವಲ್ಲ ಎಂದು ಬದಲಾಯಿತು - ಸ್ಥಿರ ಟೈಪಿಂಗ್‌ನ ಪ್ರಯೋಜನಗಳೆಂದರೆ ಬಳಕೆದಾರರು ಶೀಘ್ರದಲ್ಲೇ ಆದರ್ಶಕ್ಕಿಂತ ಕಡಿಮೆ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಮರೆತುಬಿಡುತ್ತಾರೆ. ಟೈಪ್-ಚೆಕ್ ಮಾಡಲಾದ ಪೈಥಾನ್ ಕೋಡ್‌ನಲ್ಲಿ ಯಾವುದೇ ವಿಶೇಷ ಸಿಂಟ್ಯಾಕ್ಟಿಕ್ ರಚನೆಗಳನ್ನು ಬಳಸಲಾಗಿಲ್ಲವಾದ್ದರಿಂದ, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪೈಥಾನ್ ಉಪಕರಣಗಳು ಮತ್ತು ಕೋಡ್ ಸಂಸ್ಕರಣಾ ಪ್ರಕ್ರಿಯೆಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಮುಂದುವರೆಸಿದವು, ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಹೊಸ ಉಪಕರಣವನ್ನು ಕಲಿಯಲು ಹೆಚ್ಚು ಸುಲಭವಾಗಿದೆ.

ನಾನು ನನ್ನ ಪದವಿ ಪ್ರಬಂಧವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ ಡ್ರಾಪ್‌ಬಾಕ್ಸ್‌ಗೆ ಸೇರಲು ಗೈಡೋ ನನಗೆ ಮನವರಿಕೆ ಮಾಡಿದರು. ಮೈಪಿ ಕಥೆಯ ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕ ಭಾಗವು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

ಮುಂದುವರೆಸಲು ...

ಆತ್ಮೀಯ ಓದುಗರು! ನೀವು ಪೈಥಾನ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ದಯವಿಟ್ಟು ಈ ಭಾಷೆಯಲ್ಲಿ ನೀವು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಯೋಜನೆಗಳ ಪ್ರಮಾಣದ ಬಗ್ಗೆ ನಮಗೆ ತಿಳಿಸಿ.

ಮೂಲ: www.habr.com