- Екипът на TypeScript избра порт, който да пренапише напълно, за да запази идентичността на съобщенията за грешки и семантиката.
- Събирането на боклука и първокласните затваряния на Go бяха от съществено значение за обработката на сложните структури от данни на компилатора.
- Проверката на заемките на Rust би наложила ръчни решения за циклични препратки, добавяйки ненужна сложност.
- Go осигури генериране на зрял нативен код и паралелизъм със споделена памет без никакви допълнителни усилия.
Когато екипът на TypeScript реши да пренесе компилатора си на нов език, те имаха ясна цел: всичко да работи точно както преди. Това означаваше запазване на същите съобщения за грешки и семантика, на които разработчиците разчитат от години. Според Андерс Хейлсберг, водещият архитект, пълното пренаписване не беше възможно, защото би рискувало да наруши обратната съвместимост. Вместо това, те избраха портиране – и това решение подготви почвата за изненадващ избор: да се избере Rust.
Портът се нуждаеше от език, който можеше да обработва сложните вътрешни структури на компилатора, без да налага големи промени. Екипът бързо осъзна, че събирането на боклука и първокласните затваряния са неоспорими. Go предлага и двете „наготово“, заедно със зряло генериране на нативен код и паралелизъм в споделена памет на всяка основна платформа. Rust, от друга страна, би изисквал значителни ръчни заобикаляния, особено за кръговите структури от данни на компилатора.
Защо да се избере Rust за пристанището
Хейлсберг обясни, че компилаторът е пълен с родителски указатели, рекурсивни типове и символи, които се отнасят един към друг. Те създават кръгови препратки, които са естествени в език със събиране на боклук. Изпълнителната среда на Go се справя безпроблемно с това, позволявайки на екипа да се съсредоточи върху портирането, вместо да се бори с езика. Проверката на заеми на Rust, макар и мощна за безопасност на паметта, просто не позволява тази форма, без да се прибягва до опасен код или трикове за броене на препратки. Това би добавило сложност и риск, без ясна полза.
При сравняването на двата езика, екипът не откри съществено предимство за Rust в генерирането на код или паралелизма. Генерирането на код в Go вече е зряло, а неговите goroutines предоставят прост и ефективен модел за едновременно изпълнение. Производителността на Rust може да е малко по-добра в някои крайни случаи, но допълнителните усилия, необходими, за да може компилаторът да работи с правилата си за собственост, не бяха оправдани. Портирането трябваше да бъде прагматично, а не да е демонстрация на езикови функции.
Съвместимост и семантика: Най-важният приоритет
Основният двигател на портирането беше поддържането на идентично поведение. Разработчиците разчитат на съобщенията за грешки на TypeScript , за да отстраняват грешки в кода си, и всяка промяна може да наруши работните им процеси. Чрез портирането към Go, екипът може да използва повторно съществуващата логика и структури от данни, като гарантира, че резултатът остава съвместим байт по байт. Този подход също така намалява риска от въвеждане на фини грешки, които може да донесе пренаписването.
Събирането на боклука в Go беше ключов фактор. Вътрешният граф от възли и референции на компилатора е силно взаимосвързан и ръчното управление на паметта би било кошмар. С Go екипът може да разпределя и освобождава памет автоматично, което му позволява да се съсредоточи върху логиката на компилатора. Първокласните затваряния също така улесниха имплементирането на различните проходи и трансформации, които компилаторът извършва, тъй като те могат да улавят контекста по естествен път.
Проверка на заеми на Ръст: Разбивач на сделки
Проверката на заемките на Rust е проектирана да предотвратява състезания за данни и грешки в паметта по време на компилация, но е със строги правила. Структурите от данни на компилатора на TypeScript са пълни с цикли и споделени препратки, които проверката на заемките отхвърля, освен ако не използвате опасни блокове или Rc/RefCell. Хейлсберг отбеляза, че това би наложило ръчни решения за всяка кръгова структура от данни, добавяйки шаблонен код и правейки кода по-труден за поддръжка. Нямаше предимство на генериране на код или паралелизъм, което да оправдае тази допълнителна работа.
В крайна сметка изборът беше ясен. Go предлагаше правилния баланс между простота, производителност и съвместимост. Портирането вече е в ход и екипът е уверен, че ще осигури същото TypeScript изживяване с по-бърз и по-ефективен компилатор. За разработчиците това означава, че няма изненади – просто същият надежден инструмент, който винаги са използвали, работещ на по-модерна основа.
Като се има предвид всичко, решението да се избере Go пред Rust за портирането на TypeScript се свежда до практическо инженерство. Необходимостта от събиране на боклука, първокласни затваряния и безпроблемна обработка на циклични препратки направиха Go естествения избор. Гаранциите за безопасност на Rust са впечатляващи, но те идват на цена, която екипът на TypeScript не беше готов да плати. Резултатът е портиране, което запазва всичко, което разработчиците харесват в TypeScript, като същевременно полага основите за бъдещи подобрения.
