TypeScript 7, Go அடிப்படையிலான ஒரு கம்பைலருடன் (compiler) அறிமுகமாகிறது. இது டைப்-செக்கிங் (type-checking) நேரத்தை அதன் முந்தைய கால அளவிலிருந்து பத்தில் ஒரு பங்காகக் குறைப்பதோடு, மெமரி பயன்பாட்டையும் (memory footprint) கால் பகுதி வரை குறைக்கிறது. ஒரு டெவலப்பர் VS Code-இல் “save” பொத்தானை அழுத்திய அடுத்த கணமே இந்த மாற்றத்தை உணர முடியும்.

பெரிய monorepos-களில் TypeScript-இன் incremental checker முடங்கிப்போகக்கூடும் என்ற பல ஆண்டுகால புகார்களைத் தொடர்ந்து, மொழியின் சேவையின் (language service) மையப்பகுதியை Go மொழியில் மீண்டும் எழுத Microsoft முடிவு செய்துள்ளது. parsing மற்றும் type-checking போன்ற கடினமான பணிகளை நீண்டகாலமாகப் பயன்படுத்தப்பட்டு வந்த JavaScript இம்ப்ளிமென்டேஷனில் (implementation) இருந்து மாற்றுவதன் மூலம், குழுவினர் மொழி மட்டத்தில் parallelism-ஐ (இணையாகச் செயல்படுதல்) சாத்தியமாக்கியுள்ளனர் மற்றும் Node.js runtime-இன் சுமையைக் குறைத்துள்ளனர்.

இந்த மறுவடிவமைப்பு ஏன் முக்கியமானது

Next.js அல்லது Nuxt போன்ற frameworks மூலம் உருவாக்கப்படும் நவீன இணைய செயலிகள் (web apps) வழக்கமாக ஆயிரக்கணக்கான மாட்யூல்களைப் (modules) பயன்படுத்துகின்றன. அத்தகைய சூழல்களில், முதல் டைப் பிழையைக் (type error) கண்டறியும் நேரம், edit-compile-debug சுழற்சியிலேயே அதிக நேரத்தை எடுத்துக்கொள்ளக்கூடும். புதிய கம்பைலர், VS Code-இல் முதல் பிழையைக் கண்டறியும் நேரத்தை 17.5 வினாடிகளிலிருந்து 1.3 வினாடிகளுக்கும் குறைவாகக் குறைக்கிறது; இது அந்த எடிட்டருக்கான வேகத்தை மட்டும் 11.9× அதிகரிக்கிறது. பல்வேறு திட்டங்களிலிருந்து பெறப்பட்ட சுயாதீனமான பெஞ்ச்மார்க்குகள் (benchmarks) இதே போன்ற முன்னேற்றங்களை உறுதிப்படுத்துகின்றன:

  • VS Code: 11.9× வேகமானது
  • Sentry: 8.9× வேகமானது
  • Bluesky: 8.7× வேகமானது
  • Playwright: 8.7× வேகமானது
  • Tldraw: 7.7× வேகமானது

மெமரி பயன்பாடும் மேம்பட்டுள்ளது. VS Code-இன் TypeScript server இப்போது 18% குறைவான RAM-ஐப் பயன்படுத்துகிறது, Bluesky-இல் 26% குறைவும், Tldraw-இல் 15% சேமிப்பும் காணப்படுகிறது.

இந்த எண்கள் நிஜ உலக உற்பத்தித்திறனை (productivity) பிரதிபலிக்கின்றன: ஒவ்வொரு சில வினாடிகளுக்கும் ஒரு கோப்பைச் சேமிக்கும் ஒரு டெவலப்பர், இப்போது பத்து மடங்கு வேகமாகச் செயல்பட முடியும், இது பெரிய codebase-களில் ஏற்படும் அன்றாடத் தடைகளைத் துரிதமாகக் குறைக்கிறது.

நுணுக்கமான கட்டுப்பாட்டிற்கான புதிய வசதிகள்

Go கம்பைலர், குழுக்கள் தங்களின் வன்பொருள் (hardware) மற்றும் பணிப்பாய்வுக்கேற்ப (workflow) செயல்திறனைத் தனிப்பயனாக்க உதவும் ஒரு செட் command-line flags-களை அறிமுகப்படுத்துகிறது:

  • Parallel processing (--checkers மற்றும் --builders) parsing மற்றும் type-checking ஆகியவற்றை இணையாகச் (concurrently) செயல்படுத்துகிறது, இது பயனர்கள் வேகம் மற்றும் மெமரி அழுத்தம் (memory pressure) ஆகியவற்றுக்கு இடையே சமநிலையைப் பேண அனுமதிக்கிறது.
  • Single-threaded mode (--singleThreaded) debugging-ஐ எளிதாக்குகிறது மற்றும் குறைந்த வளங்களைக் கொண்ட சூழல்களுக்கு (low-resource environments) ஏற்றது.
  • Scalable workers, builder workers-லிருந்து தனித்து type-checking workers-களை அளவிட (scale) அனுமதிக்கிறது, இதன் மூலம் தனிப்பயனாக்கப்பட்ட build pipelines-ஐ உருவாக்க முடியும்.
  • Improved watch mode, பழைய Node-அடிப்படையிலான file scanner-க்கு பதிலாக ஒரு Go file watcher-ஐப் பயன்படுத்துகிறது, இது மிகப்பெரிய node_modules மரங்களின் (trees) செலவு மிகுந்த recursive scans-களைத் தவிர்க்கிறது.

இந்த விருப்பங்கள், பெரிய நிறுவனங்கள் தங்களின் தற்போதைய குறியீட்டை (code) மாற்றியமைக்காமலேயே, CI pipelines-லிருந்து கூடுதல் செயல்திறனைப் பெற உதவுகின்றன.

அபாயங்கள் மற்றும் எதிர்ப்புகள்

ஒரு முக்கிய அங்கத்தை (core component) வேறு மொழியில் மீண்டும் எழுதுவது சர்ச்சைக்குரியது அல்ல என்று சொல்ல முடியாது. முதிர்ச்சியடைந்த JavaScript implementation ஏற்கனவே சரிசெய்துள்ள பிழைகள் அல்லது பொருந்தாமைப் பிரச்சனைகளை (incompatibilities), Go-விற்கு மாறுவதால் புதியதாகக் கொண்டு வரக்கூடும் என்று சில டெவலப்பர்கள் கவலைப்படுகிறார்கள். இந்த மாற்றம் TypeScript toolchain-இல் ஒரு Go runtime சார்பையும் (dependency) சேர்க்கிறது, இது Node.js-உடன் நெருக்கமாக இணைக்கப்பட்ட சூழல்களைச் சிக்கலாக்கலாம். ஆரம்பகாலப் பயனர்கள் (early adopters) தங்களின் தனிப்பயனாக்கப்பட்ட plugins மற்றும் language server extensions எந்த மாற்றமுமின்றி தொடர்ந்து செயல்படுவதை உறுதி செய்ய வேண்டியிருக்கும்.

அடுத்து கவனிக்க வேண்டியவை

Microsoft பொது வெளியீட்டில் (public release) Go அடிப்படையிலான கம்பைலரை இயல்புநிலையாக (default) மாற்றியுள்ளது, ஆனால் பழைய JavaScript engine மாற்றுத் தேர்வாக (fallback) இன்னும் கிடைக்கிறது. முக்கிய IDE-கள் மற்றும் CI சேவைகளில் இதன் பயன்பாட்டு விகிதத்தைக் கண்காணிப்பதன் மூலம், இந்த செயல்திறன் முன்னேற்றம், இடமாற்றச் சிரமங்களை விட (migration friction) அதிகமாக உள்ளதா என்பதைக் கண்டறியலாம். கூடுதலாக, புதிய flags குறித்த சமூகத்தின் கருத்துக்கள் கம்பைலர் எவ்வாறு பரிணமிக்கும் என்பதைத் தீர்மானிக்கும்—டெவலப்பர்கள் இணையாகச் செயல்படும் (parallel) விருப்பங்களைச் சரிசெய்வது கடினமாக உணர்ந்தால், Microsoft உயர்நிலைத் தீர்வுகளை (higher-level presets) அறிமுகப்படுத்தலாம்.

சுருக்கம்: TypeScript 7-இன் Go மறுவடிவமைப்பு பத்து மடங்கு வேகமான type checking மற்றும் குறிப்பிடத்தக்க மெமரி சேமிப்பை வழங்குகிறது. இந்த மாற்றம், சுற்றுச்சூழல் அமைப்பு (ecosystem) புதிய runtime-க்குத் தடையின்றிப் பழகிக்கொண்டால், பெரிய அளவிலான JavaScript மேம்பாட்டை உடனடியாக வேகமானதாக மாற்றும்.