TypeScript ಉತ್ಪಾದನೆಗೆ (production) ತಲುಪುವ ಮೊದಲೇ ಮೂರ್ಖತನದ ಬಗ್‌ಗಳನ್ನು (bugs) ಹಿಡಿಯುತ್ತದೆ. ತಪ್ಪಾಗಿ ಬರೆದ ಪ್ರಾಪರ್ಟಿ (property), ಮರೆತುಹೋದ ಆರ್ಗ್ಯುಮೆಂಟ್ (argument), ಮತ್ತು ತಪ್ಪು ರೂಪವನ್ನು ನೀಡುವ ಬ್ರಾಂಚ್‌ಗಳಿಗಾಗಿ (branch) ಇದು ನಿಮ್ಮನ್ನು ಎಚ್ಚರಿಸುತ್ತದೆ. ನೀವು ಅದನ್ನು ಸರಿಪಡಿಸುತ್ತೀರಿ, ಬಿಲ್ಡ್ (build) ಪಾಸಾಗುತ್ತದೆ ಮತ್ತು ನೀವು ಶಿಪ್ (ship) ಮಾಡುತ್ತೀರಿ. ಆದರೆ ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪ್‌ಗಳಿಗೆ (static types) ಒಂದು ಕಟ್ಟುನಿಟ್ಟಿನ ಮಿತಿ ಇದೆ. ಕಂಪೈಲರ್ ಕೆಲಸ ಮುಗಿಸಿದ ನಂತರ, ಪ್ರತಿಯೊಂದು ಅ𝗻ೋಟೇಶನ್ (annotation) ಅನ್ನು ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ. ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡುವ JavaScript engine ಗೆ ನಿಮ್ಮ ಇಂಟರ್‌ಫೇಸ್‌ಗಳು (interfaces), ಬ್ರ್ಯಾಂಡೆಡ್ ಟೈಪ್‌ಗಳು (branded types) ಅಥವಾ ನೀವು ಎಚ್ಚರಿಕೆಯಿಂದ ನಿರ್ಬಂಧಿಸಿದ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್‌ಗಳ (string literals) ಬಗ್ಗೆ ತಿಳಿದಿರುವುದಿಲ್ಲ. ಅದಕ್ಕೆ ಕೇವಲ ಮೌಲ್ಯಗಳು (values) ಮತ್ತು ಭಾಷೆಯ ನೈಜ ನಿಯಮಗಳು ಮಾತ್ರ ತಿಳಿದಿರುತ್ತವೆ.

ಬಿಲ್ಡ್ ಪಾಸಾಗುವುದು ಎಂದರೆ ರನ್‌ಟೈಮ್ (runtime) ಸುರಕ್ಷಿತ ಎಂದರ್ಥವಲ್ಲ. ಟೆಸ್ಟ್‌ಗಳು ಪಾಸಾದವು (green) ಎಂದರೆ ಬಳಕೆದಾರರು ಸ್ಥಿರವಾದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನೋಡುತ್ತಾರೆ ಎಂದರ್ಥವಲ್ಲ. ನಿಮ್ಮ ಮಾನಸಿಕ ಮಾದರಿಯು (mental model) TypeScript ಗಡಿಯಲ್ಲೇ ನಿಂತರೆ, ಅಪ್ಲಿಕೇಶನ್ ಕ್ರ್ಯಾಶ್ ಆಗುವ ಜಾಗದಲ್ಲಿ ನೀವು ಕಣ್ಣು ಮುಚ್ಚಿ ಪ್ರಯಾಣಿಸುತ್ತಿದ್ದೀರಿ ಎಂದರ್ಥ.

ಕಂಪೈಲ್-ಟೈಮ್ ಭ್ರಮೆ

TypeScript ನ ಇಡೀ ಟೈಪ್ ಸಿಸ್ಟಮ್ ಕಂಪಿಲೇಶನ್ ಸಮಯದಲ್ಲಿ ಅಳಿಸಿಹೋಗುತ್ತದೆ. ಯಾವುದೇ ಪ್ರಾಜೆಕ್ಟ್‌ನ ಕಂಪೈಲ್ ಮಾಡಿದ JavaScript ಔಟ್‌ಪುಟ್ ಅನ್ನು ತೆರೆದರೆ, ಅಲ್ಲಿ interface, type, ಅಥವಾ ಜೆನೆರಿಕ್ ಕನ್ಸ್‌ಟ್ರೇಂಟ್‌ಗಳ (generic constraints) ಯಾವುದೇ ಕುರುಹುಗಳು ಸಿಗುವುದಿಲ್ಲ. ಅವು ಕೇವಲ ಡಿಸೈನ್-ಟೈಮ್ ಸ್ಕ್ಯಾಫೋಲ್ಡಿಂಗ್ (design-time scaffolding) ಆಗಿವೆ. ಬ್ರೌಸರ್ ಅಥವಾ Node.js ಪ್ರಕ್ರಿಯೆಯು ಸಾಮಾನ್ಯ JavaScript ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ, ಮತ್ತು ನಿಮ್ಮ ಫಂಕ್ಷನ್‌ಗಳ ಮೂಲಕ ಹರಿಯುವ ಮೌಲ್ಯಗಳು ನೀವು ಕಾಗದದ ಮೇಲೆ ಘೋಷಿಸಿದ ಟೈಪ್‌ಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತವೆ ಎಂಬ ಗ್ಯಾರಂಟಿ ಇರುವುದಿಲ್ಲ.

ಈ ಅಂತರವು ನಿಮ್ಮ ಸಿಸ್ಟಮ್‌ನ ಅಂಚುಗಳಲ್ಲಿ (edges) ಹೆಚ್ಚು ಮುಖ್ಯವಾಗುತ್ತದೆ. ನೆಟ್‌ವರ್ಕ್ ರೆಸ್ಪಾನ್ಸ್‌ಗಳು (network responses), ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಮತ್ತು ಥರ್ಡ್-ಪಾರ್ಟಿ ಲೈಬ್ರರಿಗಳು ನಿಮ್ಮ ಟೈಪ್‌ಗಳನ್ನು ಉಲ್ಲಂಘಿಸುವ ಮೌಲ್ಯಗಳನ್ನು ಸೇರಿಸಬಹುದು. ನೀವು strictEmail: string ಎಂದು ಘೋಷಿಸಿದ ವೇರಿಯೇಬಲ್, ನಂಬಿಕೆಗೆ ಅರ್ಹವಲ್ಲದ API ಮೂಲಕ ಕೆಟ್ಟ ಡೇಟಾ ಬಂದರೆ, ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಇನ್ನೂ ಒಂದು ಸಂಖ್ಯೆಯನ್ನು (number) ಹೊಂದಿರಬಹುದು. ಯಾವುದೇ ನಿಯಮಗಳನ್ನು ಜಾರಿಗೊಳಿಸಲು TypeScript ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪ್ರೊಡಕ್ಷನ್‌ವರೆಗೆ (production) ಹಿಂಬಾಲಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ರನ್‌ಟೈಮ್ ಸಂಪೂರ್ಣವಾಗಿ ಪ್ರತ್ಯೇಕ ಮಟ್ಟದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಮತ್ತು ಈ ಎರಡೂ ಮಟ್ಟಗಳನ್ನು ಒಂದೇ ಎಂದು ಭಾವಿಸುವುದು ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ (static analysis) ಎಂದಿಗೂ ಪತ್ತೆಹಚ್ಚಲಾಗದ ವೈಫಲ್ಯಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಸಂಖ್ಯೆಗಳು ನಿಮ್ಮನ್ನು ದ್ರೋಹ ಮಾಡಿದಾಗ

TypeScript ಒಂದು number ಅನ್ನು ನೋಡುತ್ತದೆ. JavaScript engine ಒಂದು IEEE 754 ಡಬಲ್-ಪ್ರಿಸಿಷನ್ ಫ್ಲೋಟ್ (double-precision float) ಅನ್ನು ನೋಡುತ್ತದೆ. ಈ ವ್ಯತ್ಯಾಸವು ವಿನಾಶಕಾರಿಯಾಗುವವರೆಗೆ ಹಾನಿಕಾರಕವಲ್ಲ.

JavaScript ಪ್ರತಿ ಸಂಖ್ಯೆಗಾಗಿ 64 ಬಿಟ್‌ಗಳನ್ನು ಮೀಸಲಿಡುತ್ತದೆ, ಆದರೆ ಕೇವಲ 53 ಬಿಟ್‌ಗಳು ಮಾತ್ರ ಮ್ಯಾಂಟ