TypeScript வெற்றி பெற்றுவிட்டது. அதன் மூலம் நமக்குக் கிடைத்தவை இவைதான்.

விவாதம் முடிவுக்கு வந்தது. TypeScript வெற்றி பெற்றுவிட்டது. புதிய திட்டங்கள் (projects) இயல்பாகவே இதைப் பயன்படுத்துகின்றன.

உங்கள் குறியீடு (code) உடைவதற்கு முன்பே எழுத்துப் பிழைகளைக் (typos) கண்டறிவதே இதன் ஆரம்பகால நோக்கமாக இருந்தது. ஆனால் இதன் உண்மையான மதிப்பு அதைவிடப் பெரியது.

Types என்பவை காலாவதி ஆகாத ஆவணங்களாக (documentation) செயல்படுகின்றன. ஒரு function signature, நீங்கள் எதை அனுப்ப வேண்டும் மற்றும் உங்களுக்கு என்ன திரும்பக் கிடைக்கும் என்பதைத் துல்லியமாகத் தெரிவிக்கும். ஒரு பட்டியலில் புதிய விருப்பத்தைச் (option) சேர்த்தால், உங்கள் குறியீட்டின் ஒவ்வொரு பகுதியையும் புதுப்பிக்க compiler உங்களைக் கட்டாயப்படுத்துகிறது. ஒரு comment அப்படியே இருக்கும், அது உங்களுக்குத் தவறான தகவலைத் தரும்.

Refactoring இப்போது பாதுகாப்பானது. பழைய JavaScript குறியீட்டில், ஒரு field-ன் பெயரை மாற்றுவது ஒரு சூதாட்டம் போலத் தோன்றும். நீங்கள் strings-களைத் தேடி, எல்லாம் சரியாக நடக்கும் என்று நம்புவீர்கள். TypeScript-இல், நீங்கள் type-ஐ மாற்றினால், உடைந்த ஒவ்வொரு வரியையும் ஒரு to-do list போல compiler உங்களுக்குக் காட்டும். Refactoring இனி பயமுறுத்துவதல்ல; அது ஒரு சாதாரணப் பணி மட்டுமே.

Types என்பவை AI உதவியாளர்களையும் (assistants) மேம்படுத்துகின்றன.

ஒரு AI-யிடம் type இல்லாத JavaScript-ஐத் திருத்தக் கேட்டால், அது கட்டமைப்பைக் (structure) கணிக்க வேண்டியிருக்கும். நீங்கள் TypeScript பயன்படுத்தினால், அந்த type-தான் அதன் விவரக்குறிப்பு (specification). எதெல்லாம் அனுமதிக்கப்பட்டது என்பதை AI தெரிந்து கொள்ளும். AI ஏதேனும் தவறு செய்தால், compiler அதை உடனடியாகக் கண்டறிந்துவிடும். அதிகாலை 2 மணிக்கு production crash ஆவதைத் தவிர்க்கலாம்; அதற்குப் பதிலாக உங்கள் editor-இல் ஒரு சிவப்பு வரியைக் காண்பீர்கள்.

Types உங்களைத் தாமதப்படுத்தாது. AI உலகத்தில், அவை உங்கள் வேகத்தை அதிகரிக்கும். அவை பாதுகாப்பு வேலிகளாக (guardrails) செயல்படுவதால், உருவாக்கப்பட்ட குறியீட்டை (generated code) நீங்கள் நம்பலாம்.

உங்கள் types-களை நோக்கத்துடன் எழுதுங்கள்:

• பல booleans-களுக்குப் பதிலாக unions-களைப் பயன்படுத்துங்கள். ஒன்றுக்கொன்று முரண்படக்கூடிய மூன்று flags-களை விட, "loading" | "error" | "ready" போன்ற ஒரு status சிறந்தது. • உங்கள் domain types-களுக்குப் பெயரிடுங்கள். உங்கள் நோக்கத்தைக் காட்ட type Cents = number என்பதைப் பயன்படுத்துங்கள். • "any"-யைத் தவிர்க்கவும். அதற்குப் பதிலாக "unknown"-ஐப் பயன்படுத்தி அதைச் சுருக்கவும் (narrow it down). "Any" என்பது உங்கள் பாதுகாப்பு வலையில் ஒரு ஓட்டையை உருவாக்குகிறது. • inference-ஐச் செயல்பட விடுங்கள். எல்லாவற்றிற்கும் லேபிள் (label) செய்ய வேண்டிய அவசியமில்லை. function signatures போன்ற உங்கள் எல்லைகளை மட்டும் லேபிள் செய்யுங்கள், மற்றவற்றைத் தானாகவே நடக்க விடுங்கள்.

TypeScript வெறும் எழுத்துப் பிழைகளைக் கண்டறிவதோடு நின்றுவிடவில்லை. அது கட்டாயப்படுத்தப்பட்ட ஒப்பந்தங்களை (enforced contracts) உருவாக்கியுள்ளது. இந்த ஒப்பந்தங்கள் பயமில்லாத refactoring மற்றும் நம்பகமான AI கருவிகளுக்கு வழிவகுக்கின்றன.

பிழைகளைத் (bugs) தடுக்கவே நாங்கள் types-களைப் பயன்படுத்தத் தொடங்கினோம். ஆனால் அவை மற்ற அனைத்திற்கும் அடிப்படையாக இருப்பதால், இப்போதும் அவற்றைப் பயன்படுத்துகிறோம்.

ஆதாரம்: https://dev.to/parsajiravand/typescript-won-heres-what-that-actually-bought-us-12m8