This is the csharp target for tsonic (a TypeScript to C#/Rust/Python/Triton transpiler). It has a bunch of tests here: https://github.com/tsoniclang/tsonic-csharp/tree/main/test

More comprehensive e2e proving grounds are at

1: https://github.com/tsoniclang/proof-is-in-the-pudding

2: https://github.com/tsoniclang/tsumo/

They were built specifically for testing the C# target. There are several other large projects we built specifically for e2e testing.

But more interesting would be the tooling built to support this. For example, our current TypeScript parser [1] is a file-by-file port of Microsoft's TypeScript V7 compiler written in golang. The challenge here is that every time Microsoft changes code, we'll have to fix our code and tests. It's doable, but a fair amount of work.

So we decided to write tooling to transpile Microsoft's v7 compiler from golang, and autogenerate our compiler. That tool is called gotots [2] - and it already produces a fully working TypeScript compiler. It's 3x slower than TypeScript v6 compiler, but we hope to get to rough performance parity in a week or so. Everytime Microsoft makes an update, we run gotots and our parser gets updated as well.

[1]: The old parser - https://github.com/tsoniclang/tsts-legacy

[2]: Golang to TypeScript transpiler - https://github.com/tsoniclang/gotots

My general point is that tests and tooling is tremendous value, and they are guardrails for LLMs to converge. I could have, for example, chosen not to write the go-to-ts transpiler, and live with porting Microsoft's parser line by line. But making such tools is something LLMs are good at, so it's a tradeoff well worth making. And the upside is that you don't have to use LLMs to port Microsoft's parser/compiler (a large and complex project) line by line.

The TypeScript code which was transpiled into Rust (and is compatible with most hugo templates) runs faster than the original hugo.

[1]: https://github.com/tsoniclang/tsonic-examples/tree/main/rust...

The transpiler is still WIP, but the fact that it can do this says a lot of about how far LLMs have come.

$1B or even $5B is nothing, given the impact UPI has had across the country.

Correlation is not causation. Banks have demanded this (getting rid of Zero MDR) for many years, even prior to Trump assuming office. However, it may have momemtum now due to the impending trade deal. But that's speculation either way, and the burden of proof rests with whoever is making that assertion.

What the government conceded (or gained, which could be a boring topic relatively) would make an impactful story. Unfortunately, newpapers today mostly rely on correlation rather than doing the hard work of finding someone who'll spill the beans. There's very little of Tehelka-style "Operation West End" (or "All the President's Men" for a movie equivalent) going on these days.

Comments URL: https://news.ycombinator.com/item?id=49248024

Points: 1

# Comments: 0

1. TS only has a "number" type. But what type of number is it? This is doable safely via keywords (or known markers), or sometimes via analysis, but I couldn't find it in the README.

2. A compiler that works only on macOS?

For a potential customer deciding whether to trust a relatively small app (compared to Google and Apple) with their memories, these are useful numbers. 50% increase in paying customers this year. Nearly half a million registered users, with a 40% growth in the last 6 months. 5% of their users are paying customers. Revenue topping a million. That's stuff I want to know if I'm subscribing and uploading all my pics to their servers. I want to know if they'll be around, and my stuff is safe.

> So for folks that don’t know better, this is a very cool thing ente is doing. For folks that run businesses and know better...

Oh please. Perhaps work on not jumping to conclusions too quickly.

They seem to be making good progress, starting out from Trung Nguyễn's effort. This would be a massively impactful project, and could revive the Hackintosh.

Comments URL: https://news.ycombinator.com/item?id=48907953

Points: 1

# Comments: 1

I'm using Rust as a placeholder for a language with excellent performance and safety characteristics. It may not be a good thing, but there's no way around it.

Over the past year, I've been working on porting the v7 tsgo compiler back into TypeScript - https://github.com/tsoniclang/tsts

It's fully functional now, but 2x slower than the original tsc and 10x slower than tsgo. But hopefully in a month or so, we'll get to C# and Rust targets and it should be able to compile itself to become nearly as fast as tsgo.