TypeScript Blog

There's the blog post (by Anders Hejlsberg, the author of Turbo Pascal, chief architect of Delphi, currently lead architect of C# and a core developer of TS; I'd say he knows his languages), but they also posted FAQs, here's some good reads: The blog post: https://devblogs.microsoft.com/typescript/typescript-native-port/ Why Go? https://github.com/microsoft/typescript-go/discussions/411 Why a port instead of a rewrite? https://github.com/microsoft/typescript-go/discussions/410

Well it does suck, and it isn't really great for implementing performant developer tools, such as parsers, formatters and so on. The performance is that bad that the typescript developers are rewriting the language itself in Go. [0] Tells me everything I need to know about how bad typescript is from a performance stand point. [0] https://devblogs.microsoft.com/typescript/typescript-native-port/

I know Typescript now has a `moduleSuffixes`[0] option that may be be a reference point for making this easier. I am imagining you want to do this due to compiler conditions for build tooling no? This makes it "transparent" to the developer but retains the file naming approach, best of both worlds? [0]: https://devblogs.microsoft.com/typescript/announcing-typescript-4-7/#r…

The original proposal has lots of caveats, justifications, and pre-empts many comments and questions that people seem to be asking here, so I'd recommend people to take a look at that instead: https://github.com/giltayar/proposal-types-as-comments/ Also the announcement: https://devblogs.microsoft.com/typescript/a-proposal-for-type-syntax-i… And HN discussion: https://news.ycombinator.com/item?id=30618681

Short comment about the 'unknown' type: TypeScript 4.4 had me learning about it very recently, because 'unknown' has been made the default type in 'catch (error)' clauses [0]. So most of our code in 'catch' blocks suddenly didn't compile any more after an unsuspecting update of the TS version. Which is a good thing, because in reviewing those I found several places where incorrect assumptions were being made about the type of error that would be caught. (side note: TypeScript does not follow SemVer; they just promise to avoid breaking changes in Patch updates, but don't promise anything won't break in Minor updates [1]) [0]: https://devblogs.microsoft.com/typescript/announcing-typescript-4-4/#u… [1]: https://github.com/microsoft/TypeScript/issues/14116#issuecomment-2804…

The TypeScript ecosystem is amazing - partly because of the large number of users also also because of the sense of community. It is run as a true OSS project. Roadmaps are release plans are all public on GitHub. Even as outsiders we've been able to contribute significant features, e.g. Private Fields in TypeScript 3.8. https://devblogs.microsoft.com/typescript/announcing-typescript-3-8/#e…

You don't need lodash/underscore, you need ramda[0]! I been using ramda heavily for tasks like merging data from normalized redux stores and it's been really handy, but it's also great for simple tasks as well. I find the resulting utilities really easy to test and since Typescript got much better at higher order type inference, it's become much easier to use ramda in a Typescript project. EDIT: The version of typescript that improved higher order type inference was 3.4[1] 0: https://ramdajs.com/ 1: https://devblogs.microsoft.com/typescript/announcing-typescript-3-4/

> Typescript has always included extensions in the output of imports. When you used a bare TS file import without an extension it added a .js extension in the transpiled output. .js file extensions have always worked in Typescript (going back to 0.x days). It was not. https://github.com/microsoft/TypeScript/issues/16577 There was proposal and PR, but It was rejected. When writing ESM in typescript, you need to import with .js extension. >There's (luckily) no such thing as an "ESM variant" of Node and browsers will never have to know anything about the .mjs file extension. (Web servers will to make sure the present the right mime type, but that's a separate issue.) They just need ESM. I stand by accusing Node of doing the silly thing by adding the .cjs and .mjs file extensions. (I understand why they did it and mixed-module libraries were a thing that needed to exist until LTS support for ESM was well adopted, but we're past that transition phase, it wasn't that long of a transition phase, and in hindsight I think it still feels a little silly. Useful, but silly.) There is absolutely such thing. Spec is either intentionally not being followed (babel) or it allows for host implementation to define some things (node.js, deno). > but we're past that transition phase, We are not. 99% of new projects use ESM with CommonJS resolution today!. Most codebases have no way to transition to ESM. It was a Herculean effort for typescript codebase to be migrated into ESM…

If you're happy with a single bundled file, another option is: deno bundle 'https://esm.sh/@observablehq/plot' > plot.js My browser development workflow looks somewhat like the following: Imports / versions in importmap.json: { "imports": { "plot": "https://esm.sh/@observablehq/[email protected]" } } Code in app.js: import * as Plot from "plot"; const plot = Plot.rectY( {length: 10000}, Plot.binX( {y: "count"}, {x: Math.random})).plot(); const div = document.querySelector("#myplot"); div.append(plot); For development use dev.html: <!DOCTYPE html> <html> <head> <meta charset="utf-8" /> <script type="importmap" src="./importmap.json"></script> <script type="module" src="./app.js"></script> </head> <body> <div id="myplot"></div> </body> </html> Then you can then bundle with: deno bundle --import-map=importmap.json app.js > bundle.js And have as your prod.html: <!DOCTYPE html> <html> <head> <meta charset="utf-8" /> <script type="module" src="./bundle.js"></script> </head> <body> <div id="myplot"></div> </body> </html> Note that `deno bundle` is deprecated. You can almost replace it with esbuild but it currently lacks builtin support for import maps: deno run --allow-all https://deno.land/x/[email protected]/mod.js --bundle app.js --outfile=bundle.js. # errors, see:…

How many years have you been doing this? How many hours have teams you've worked on spent configuring build pipelines? How many people have you seen to go other mentors or helpers in your org when they are setting up a new project? How many many times have you seen someone start from from nothing & be done in <1 hour? This post feels like a trivialization of how complicated everything is, how complexly interlinked build systems are. It also misses one of the biggest harms. It doesn't consider what a pain in the ass it is when the source/libraries you are consuming have already been downcompiled into lesser JS via someone elses perhaps-poorly configured build pipeline. I'd guess that >80% of TypeScript modules don't export ESM right now. TypeScript 4.7 is about two weeks old & it's the first time TypeScript and Node's ESM play well[1]. Because it all involves complex transpilation. How many modules do you think will get updated, ever? You know what would be great? If we could just write code. If we didn't have to worry about build pipelines. If my toolchain could make what it would of other code, be it JS or JS+TypeScript Type Annotations or JS+Flow Type Annotations. > "For frontend usually you literally don't configure anything, Next.JS, CRA, or whatever" "For backend node, you simply edit a couple of lines in the package.json" The amount of dissympathy for the real complexity here, for how hard a couple specific projects have worked to make things "just go" is…

https://devblogs.microsoft.com/typescript/typescript-native-port/ https://github.com/microsoft/typescript-go

The compiler was written in TS; it wouldn't make much sense to compile TS to Wasm, only to have that same code run in the same interpreter as the JS code. And yes, threading was a big part of it. See also: https://devblogs.microsoft.com/typescript/typescript-native-port/

I think this is an LLM summary of the post linked at the very bottom https://devblogs.microsoft.com/typescript/announcing-typescript-7-0-rc… which was previously discussed here https://news.ycombinator.com/item?id=48586001

Except JavaScript isn't "crazy fast". Not by a long shot. How did Microsoft just make Typescript 10x faster? Oh right, by reimplementing it in Go. https://devblogs.microsoft.com/typescript/typescript-native-port/ See also: https://blog.metaobject.com/2015/10/jitterdammerung.html Please don't use Electron.

You need Typescript 6 for that too: https://devblogs.microsoft.com/typescript/announcing-typescript-6-0-rc…

Few people seem to recall that MS is making tsc, the typescript compiler, faster, and as a result VSCode: https://devblogs.microsoft.com/typescript/typescript-native-port/

A very timely endeavor indeed https://devblogs.microsoft.com/typescript/typescript-native-port/

This specific one is actually supported since TypeScript 5.0: https://devblogs.microsoft.com/typescript/announcing-typescript-5-0/#@… But not properly documented (https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.htm… which shows how much Microsoft neglects JS + JSDoc workflow. Github issues have been created a long time ago, but nothing has been done so far. Apparently Microsoft is too busy with their AI slop to work on actually useful stuff.

You should look into the latest posts on the subject. > Just as a reminder, even without --incremental, TypeScript 7 often sees close to a 10x speedup over the 6.0 compiler on full builds! https://devblogs.microsoft.com/typescript/progress-on-typescript-7-dec…

> We’ve seen 2x speed improvements in type checking times for internal projects when using TSGO. That's a lot less that what TSGO promised when it was first announced (A 10x faster Typescript¹). Hopefully this is just the result of it being experimental. 1: https://devblogs.microsoft.com/typescript/typescript-native-port/

Go can do just as well in tooling. Microsoft chose Go for tsc rewrite. https://devblogs.microsoft.com/typescript/typescript-native-port/ And then there's esbuild, also in Go, which revolutionized web bundling speed https://esbuild.github.io

This is fascinating. I really bought into the original explanation [0], but seems like it was not the (full) truth. [0] https://devblogs.microsoft.com/typescript/typescript-native-port/

> I don't see any reason to evaluate Go at all. https://devblogs.microsoft.com/typescript/typescript-native-port/

Microsoft rewriting typescript tools in Go and getting a 10x speedup? It's wild that they would choose Go for that. And a surprising level of speedup. https://devblogs.microsoft.com/typescript/typescript-native-port/

TypeScript compiler has also moved to Go https://devblogs.microsoft.com/typescript/typescript-native-port/

There is this with does not do type checking: https://devblogs.microsoft.com/typescript/announcing-typescript-5-8/#t… This will only allow you to run your TypeScript in Node, but does not perform type checking, and I don't believe has any plans to. This is from Node.js 23.9.0 https://nodejs.org/api/typescript.html#type-stripping I don't believe Node has any plans for type checking TS.

We use sorbet pretty extensively. Overall it's been a net positive, but if you're coming from something like typescript, IMO it's far, far behind in terms of usability. You can get pretty good value from things like intellisense in your editor, knowing that the constant you're referencing or method you're calling exists etc, but most libraries have no typings in sorbet-typed (beyond `T.untyped`). The last post on Sorbet's blog was from 2022 https://sorbet.org/blog/, so I'm not sure how actively it's being developed. (compare that to typescript where you have a post every month https://devblogs.microsoft.com/typescript/)

Any reason the Twitter announcement is linked? The official announcement is at https://devblogs.microsoft.com/typescript/announcing-typescript-5-6/

Why is taking out the part that actually checks the types at the developer's side a huge blessing? Or if you are hoping to get the benefit of type checking in the browser itself (taking the same sweet time as tsc, but this time on every browser instead of once in the CI), then how long would you want to wait to be able to actually use the new typing functionality described in e.g. the latest TS annoucement? https://devblogs.microsoft.com/typescript/announcing-typescript-5-5/ . Because it would take a while until that would then become the standard and then become available in every browser. And you still need to provide the JS versions, because not every browser is going to support TS. In the meanwhile you could just keep using tsc just as before and get access to new functionality immediately. (I imagine you could run tsc in the browser right now if you really wanted to.)

> And “unknown” is basically broken for type narrowing. How? Typescript 4.9 improved it for type narrowing significantly. https://devblogs.microsoft.com/typescript/announcing-typescript-4-9/#i… Last weekend I actually hacked an an experiment to codegen narrowing unknown to a specific type and it works pretty well https://github.com/joshhunt/codegen-json-validator-experiment/blob/mai…