News for hackers. Stuff that matters.
Re:Moving from TypeScript to Rust / WebAssembly by melling on Wednesday July 08, 2020 @11:11PM (#23776593)
I don’t know Rust and haven’t done JavaScript for years but isn’t JavaScript a bit more of a higher level language, which would make a developer more productive?

Rust being closer to the hardware should require more code, and effort, to accomplish the same task.

Re:Moving from TypeScript to Rust / WebAssembly by echelon on Wednesday July 08, 2020 @11:35PM (#23776704)
> isn’t JavaScript a bit more of a higher level language

Rust has zero-cost abstractions that feel like using Ruby and a rich type system that makes it incredibly expressive. Working in other languages feels like going back to assembly.

I wouldn't want to design state machines in any other language. Rust's enums make it feel smooth as butter. They're a killer app. (The whole ecosystem is. Cargo. Package naming. Traits. So much good stuff.)

Rust is my most productive language now, and I work in Python, Java, and Typescript codebases frequently.

Edit: I'm being downvoted for expressing preference? What's with all the Rust hate? Learn it instead of being a hater. It's a wonderful tool, and it's silly to dismiss because you think people are being hipsters or something. There's a reason people love it.

Re:Moving from TypeScript to Rust / WebAssembly by shpongled on Wednesday July 08, 2020 @11:50PM (#23776770)
I'm a big Rust fan too. I have experience in all of the languages you've mentioned, and I'm most productive in Rust as well.

It's funny you mention enums, there was just another thread last week where I brought up how crazy it is that sum types (Rust enums) and pattern matching have been around since the 70s but have largely been limited to the FP languages. After extensively using Rust for ~3 years now, I don't ever want to use a language without sum types - you can write incredibly expressive and concise code with them.

The other major productivity boost for me is the ability to compose and chain Iterators and mix those with collection types.

Re:Moving from TypeScript to Rust / WebAssembly by hombre_fatal on Thursday July 09, 2020 @12:19AM (#23776900)
People often demand generics in Go. But I think that actual sum types would be a bigger boon (if I got to choose).

You can basically avoid interface{} in generic Go code with some copy and paste. But you can't really avoid it when you're trying to write code that would be cleaned up by an actual sum type.

Not to commit the predicable sin of comparing Rust to Go any time either is brought up. I just mean to +1 the idea that sum types should actually be a fundamental tool that we can reach for in every language. So weird that it's taking so long to go mainstream, so to speak.

Re:Moving from TypeScript to Rust / WebAssembly by eloff on Thursday July 09, 2020 @12:34AM (#23776966)
I just implemented an iterator in rust yesterday. After having done it in c++ back in the day, I was blown away by how easy and powerful it is.
Re:Moving from TypeScript to Rust / WebAssembly by zenhack on Thursday July 09, 2020 @02:12AM (#23777425)
I think a lot of the best the best things in Rust don't really have anything to do with low level programming per-se. And I find that for most applications, even with all of the extra goodness, the lack of a GC totally craters productivity. Its not because I'm fighting the borrow checker -- I got the hang of it pretty quick. But it means that every API is complicated by the need to think about lifetimes and ownership, having to think about different types of smart pointer, etc. It means you have to manage all of these silly little details which for most applications are pretty irrelevant.

This isn't a criticism of Rust; it's specifically designed for applications where those things do matter. But for the overwhelming majority of apps they don't, and I'd reach for a different tool.

I've found that once I get into a rhythm and I've been working on something in Rust for a bit, it doesn't feel that hard to deal with all that. And a few times I've thought to myself "hey maybe the GC isn't actually buying you all that much?" But then I go back to a GC'd language and watch just how much faster stuff gets done. It's not even close. I think it's one of these things where your brain doesn't notice the time that goes by when you're doing what is essentially mindless busywork.

Part of this is also having come from doing a fair bit of stuff in Haskell, Elm, and a bit of OCaml; the best "high-level" language features are inspired by that language family (including enums) and so it feels like a better control for the difference a GC makes vs. js and friends. It makes a big difference.

Re:Moving from TypeScript to Rust / WebAssembly by blub on Thursday July 09, 2020 @02:20AM (#23777475)
What's puzzling is why a language designed for memory safety and low-level control and performance is even being considered for web development where they had the former all along and they generally don't care about the latter. Or if they do they use Java, Go or throw a couple dozen more servers at the problem.
Re:Moving from TypeScript to Rust / WebAssembly by ragnese on Thursday July 09, 2020 @07:46AM (#23779130)
It's because it also has expressiveness features that Java and Go don't.

* Better handling of "null"-ness

* Sum types

* Stricter/different error-handling

* Move semantics, which can actually be nice for some APIs outside of any performance considerations

Kotlin checks a couple of these boxes, but then is also GC'd, so also gets rid of a lot of "noise" that would be in the equivalent Rust code.

For typical backend junk, I'd be Kotlin first, but I'd definitely consider Rust if performance (non-IO) was a concern.

Re:Moving from TypeScript to Rust / WebAssembly by entha_saava on Thursday July 09, 2020 @04:03AM (#23777977)
With all the "Rust is as productive as X" and "If your data structure/logic won't work in rust, it was bad design" bullshit the silent majority of us are accustomed to see on HN..
Re:Moving from TypeScript to Rust / WebAssembly by imtringued on Thursday July 09, 2020 @05:38AM (#23778463)
With Java you only need to throw more RAM at the server. The performance is perfectly acceptable compared to something like Python or Ruby. You can always squeeze out more performance with Rust but the primary benefit is the lack of a GC.
Re:Moving from TypeScript to Rust / WebAssembly by sweeneyrod on Thursday July 09, 2020 @06:24AM (#23778665)
I don't understand your last sentence. What benefits does lack of a GC have other than more performance?
Re:Moving from TypeScript to Rust / WebAssembly by zozbot234 on Thursday July 09, 2020 @05:47AM (#23778508)
A bit offtopic for HN, but that's a really nice username. (Just looking at that, I can definitely see how you'd find those things puzzling!)
Re:Moving from TypeScript to Rust / WebAssembly by zozbot234 on Thursday July 09, 2020 @05:44AM (#23778491)
> But it means that every API is complicated by the need to think about lifetimes and ownership, having to think about different types of smart pointer, etc. It means you have to manage all of these silly little details which for most applications are pretty irrelevant.

Rust gives you the features to auto-manage these "silly little details", you simply have to opt-in to them with a bit of boilerplate. Stuff like Rc<RefCell<T>> and the like is there for a reason.

Re:Moving from TypeScript to Rust / WebAssembly by zenhack on Thursday July 09, 2020 @02:14PM (#23783240)
You still have to deal with the fact that existing APIs use a broader range of types; using Rc everywhere in your own code doesn't save you from dealing with library interfaces.

Also "stuff like" is kind of the problem; all of the smart pointer types have differences that matter, and none of them is general enough to cover all use cases. Arc<Mutex<Box<T>>> comes the closest to a "general" solution, but the boilerplate is rather a lot just for the sake of not having to think about this stuff, and you still can't use it if T isn't Send.

You're really picking a fight with the language if you insist on avoiding making these decisions, and in the end it will just slow you down even more than going with the grain. And to add insult to injury, if you write all your code like that it'll likely be slower than OCaml or Haskell anyway. Rust can't keep up with a good GC on allocation throughput; the performance advantages come from managing things yourself (and avoiding heavy allocation in the first place).

Rc and friends are useful, but they don't make the problem go away.

As I said, it's not that it's even really all that hard. But it is time consuming.

Re:Moving from TypeScript to Rust / WebAssembly by afiori on Thursday July 09, 2020 @04:10AM (#23778016)
In a sense Rust could have tried to become a "tiered" language with 2 standard libraries: one low level that allows precise control on heap allocations (including custom allocators) and another higher level that relied on a GC. They could both be used at the same time.

There would also be a compiler attribute #![no_gc] that make it so that you have to provide your own implementation of the GC runtime to use GC types. (similar to how executors work for futures)

Re:Moving from TypeScript to Rust / WebAssembly by throwaway8941 on Thursday July 09, 2020 @05:05AM (#23778290)
D tried that one. I don't know it very well, but I believe it turned out not to be a good idea.
Re:Moving from TypeScript to Rust / WebAssembly by hombre_fatal on Thursday July 09, 2020 @12:14AM (#23776887)
When you're writing synchronous, single-threaded code like, say, a binary file parser or even an HTML scraper with blocking APIs, Rust is 1:1 with high level languages, and usually better.

Where Rust diverges is when you're doing async or multithreaded things with complicate lifetimes.

Getting things right from the start instead of solving them JIT as runtime issues pop up in production over the course of the year is Rust's wheelhouse. But even after using Rust for three years, I sometimes feel like I'm one requirement-change away from a problem I can't solve myself in Rust where I could solve it in a couple hours in another language.

Re:Moving from TypeScript to Rust / WebAssembly by zozbot234 on Thursday July 09, 2020 @05:55AM (#23778540)
> But even after using Rust for three years, I sometimes feel like I'm one requirement-change away from a problem I can't solve myself in Rust where I could solve it in a couple hours in another language.

Rust does have these sorts of issues wrt. managing highly generic graph-like data, possibly with cycles. That's where tracing GC actually shines, and where writing that whole portion separately in something like Go might be the right answer.

Re:Moving from TypeScript to Rust / WebAssembly by hombre_fatal on Thursday July 09, 2020 @08:59AM (#23779686)
Yep.

When I'm writing Go, I spend the whole time yearning for the abstractions of Rust, becoming a little more bitter each time I copy and paste or have to manually reify interface{}, knowing my ceremonious verbose Go code is slower than the simpler compact Rust solution.

When I'm writing Rust, I'm loving life until I hit this sort of "intractable" [for me] problem, and I wonder if I should have used Go for this part.

Re:Moving from TypeScript to Rust / WebAssembly by steveklabnik on Thursday July 09, 2020 @09:17AM (#23779826)
That is true if you have to write your own. 99.99% of the time, if you need a graph, you use petgraph and move on with life.
Re:Moving from TypeScript to Rust / WebAssembly by jfkebwjsbx on Thursday July 09, 2020 @08:35AM (#23779493)
Reference-counted graphs are usually quite fine.
Re:Moving from TypeScript to Rust / WebAssembly by jfkebwjsbx on Thursday July 09, 2020 @03:41AM (#23777875)
You are probably being downvoted because of this sentence:

> Working in other languages feels like going back to assembly

This is not a preference, it is an exaggeration and an attack on all other languages.

It is also quite ironic given Rust is intended for low level programming.

Re:Moving from TypeScript to Rust / WebAssembly by Scarbutt on Thursday July 09, 2020 @01:23AM (#23777176)
I have seen this being asked many times in /r/rust and 90% of the answers disagree with you. A common theme is to explore in Python then rewrite in Rust.
Re:Moving from TypeScript to Rust / WebAssembly by nightowl_games on Thursday July 09, 2020 @02:15AM (#23777450)
gamedev here and I basically do exactly this. explore in GDScript, rewrite in cpp.

(GDScript is pretty much python)

Re:Moving from TypeScript to Rust / WebAssembly by blub on Thursday July 09, 2020 @02:24AM (#23777494)
There's the hype and there's the reality. Some people don't appreciate the former much and reach for the down arrow...

Rust is nowhere near the productivity of Ruby or Python. If that's the case for you maybe your projects have some peculiarities or it's a personal thing.

Re:Moving from TypeScript to Rust / WebAssembly by bluejekyll on Wednesday July 08, 2020 @11:42PM (#23776732)
This is complicated. I’m no expert with WASM, but I’m fairly familiar with Rust and have toyed around with Rust and WASM.

With Rust and WASM you pay an expense of FFI between the languages. There are tools that minimize this, but there’s still a cost. Transferring data is limited to very primitive data types today, which adds a cost to translation between Rust and JS. I expect this to reduce in cost as WASM gains abilities to access the DOM and such, but it is overhead. This generally means that for many things Rust is not much faster than JS, but it is for very hot loops over CPU bound computations.

As to productivity. This debate between languages will never end. JS like Python and other interpreted languages give the impression that tasks are being accomplished, but until all code paths are tested, knowing if it is correct is not obvious.

Rust like many other typesafe languages (and it’s definitely on the further end of type safe) allow the compiler to detect errors in usage at compile time, well before testing and production usage. Some of us consider this to be more “productive” as it reduces the overall maintenance of the program after it’s released, but YMMV.

Re:Moving from TypeScript to Rust / WebAssembly by azakai on Thursday July 09, 2020 @10:33AM (#23780684)
This is an important point.

Languages compiled to wasm have an FFI cost, and we will never fully remove it because it just uses different types than Web APIs do. This isn't a Rust problem or a C problem, it's just how wasm is.

Wasm also can't use the JS standard library, and usually ends up shipping some runtime support, like malloc or string handling, which increases download size.

Both of those limitations are why wasm won't make sense for the great majority of web dev work. But wasm shines for "engine" type code, like in this post - pure computation, without lots of links to the outside JS/DOM world.

Re:Moving from TypeScript to Rust / WebAssembly by jevgeni on Thursday July 09, 2020 @05:14AM (#23778337)
Best comment in this thread. To the point and factual.
Re:Moving from TypeScript to Rust / WebAssembly by satvikpendem on Wednesday July 08, 2020 @11:23PM (#23776649)
Rust actually can be a higher language. It has true generics, static algebraic data types, functional programming features, and so on, even as it is closer to the metal. It is closer to Haskell or OCaml, but more pragmatic.
Re:Moving from TypeScript to Rust / WebAssembly by sweeneyrod on Thursday July 09, 2020 @06:28AM (#23778686)
In what ways is Rust more pragmatic than OCaml?
Re:Moving from TypeScript to Rust / WebAssembly by fluffything on Thursday July 09, 2020 @07:24AM (#23778979)
Does not really require you to drop to a lower-level language for performance, unless you really need to use assembly for something.

OCaml is great for the application level stuff, and also performs quite well in general. But for building fundamental parts of the stack in which perf is important (like the multi-threading runtime, the garbage collector, etc.) you need to drop down to C++, C, or Rust.

OCaml is definitely much nicer to use than C and C++. But I don't find it that much nicer to use than Rust TBH.

Re:Moving from TypeScript to Rust / WebAssembly by wtetzner on Friday July 10, 2020 @10:17AM (#23791684)
> OCaml is definitely much nicer to use than C and C++. But I don't find it that much nicer to use than Rust TBH.

I find OCaml quite a bit nicer to use than Rust, though in a lot of ways that's due to my preference for structuring code using modules and functors.

However, due to Cargo and the fact that Rust has good Windows support, I end up reaching for Rust much more often than I do for OCaml.

Re:Moving from TypeScript to Rust / WebAssembly by fluffything on Monday July 13, 2020 @03:55AM (#23818253)
Modules is pretty much the only OCaml feature I miss in Rust. I can work around functors with some effort in Rust, and hopefully GATs will make this even simpler (although I don't expect GATs to give Rust functors).
Re:Moving from TypeScript to Rust / WebAssembly by satvikpendem on Thursday July 09, 2020 @06:32AM (#23778702)
A good package manager, multicore support, larger community, and so on.
Re:Moving from TypeScript to Rust / WebAssembly by genuine_smiles on Wednesday July 08, 2020 @11:28PM (#23776679)
Rust’s type system is sound, unlike TypeScript, and Rust provides a lot more performance by default. You can get good performance out of JavaScript, but it can be difficult, and the code can end up being difficult to maintain.

If you’re trying to right very fast, very correct code in JavaScript/TypeScript then Rust may be more productive.

Re:Moving from TypeScript to Rust / WebAssembly by phailhaus on Wednesday July 08, 2020 @11:18PM (#23776620)
Depends on what you're optimizing for. If you want memory efficiency and near-native speeds, then you need WebAssembly. And Rust is a fantastic source language to compile to WebAssembly because of its memory safety.
Re:Moving from TypeScript to Rust / WebAssembly by iMuzz on Wednesday July 08, 2020 @11:20PM (#23776628)
Mind explaining a bit more here why Rust is a particularly good language to compile to wasm? Why does memory safety help here?

Asking out of ignorance!

Re:Moving from TypeScript to Rust / WebAssembly by connicpu on Wednesday July 08, 2020 @11:59PM (#23776813)
There isn't necessarily any inherent thing about the language itself that makes it better at WASM than others, it's more that it was one of the first languages that was ready for WASM.

- It's low level like C and C++ so it maps cleanly onto WASM

- In your average Rust project, all dependencies are already built from source, greatly increasing the likelihood all your dependencies can be built for WASM

- Already using LLVM as the compiler backend made WASM targeting a lot less work than for languages that need to do that work from scratch

- Probably most importantly, a lot of developers involved in core rustc development were motivated to get Rust working on WASM

At least that's my perception for how Rust became such a prominent language for WASM development early on

Re:Moving from TypeScript to Rust / WebAssembly by jillesvangurp on Thursday July 09, 2020 @03:24AM (#23777792)
You forgot the most important thing: it doesn't need a garbage collector. This is important because wasm garbage collection is a work in progress.

The solution other languages targeting wasm typically use is bundling their own garbage collector in the compiled code, which of course adds a bit of code bloat. E.g. C# blazor wasm applications are not exactly small for this reason.

There was a message yesterday in the Kotlin slack about them starting work on a wasm compiler backend for Kotlin (they already have java, native, and js compilers). https://github.com/JetBrains/kotlin/tree/master/compiler/ir/... Interestingly they plan to depend on the wasm GC proposal instead of bundling their own: https://github.com/WebAssembly/gc/

So, things are improving on this front. But it's a big reason why Rust is particularly popular for wasm right now because they have no GC and lots of developer tools that are relatively mature because they've been working on this for a while.

IMHO, this will take another few years to fully mature but inevitably lots of people are going to be writing web applications that don't involve any or very little javascript. Kotlin is starting to look very solid for any kind of cross platform Android, IOS, and web based development (as well as server development, which is what I do). Swift would be another candidate and there already is a wasm compiler for that as well.

Re:Moving from TypeScript to Rust / WebAssembly by rhlsthrm on Thursday July 09, 2020 @10:44AM (#23780819)
Interesting, one of the big reasons I want to learn Rust is to "future proof" myself once JS loses its monopoly on the web. Maybe Kotlin will be a better one than Rust?
Re:Moving from TypeScript to Rust / WebAssembly by jfkebwjsbx on Thursday July 09, 2020 @08:44AM (#23779557)
> - In your average Rust project, all dependencies are already built from source

That is only the case for open source code like crates.io, there is nothing that guarantees you will get the source code of a third-party, though.

I mention this because in the native world it is common to give customers precompiled libraries.

> - Already using LLVM as the compiler backend

Some people don't seem to know this, but all languages that target LLVM (including C, C++, Fortran, Ada, Julia, Swift and others) can be used in WebAssembly.

Re:Moving from TypeScript to Rust / WebAssembly by steveklabnik on Thursday July 09, 2020 @09:27AM (#23779898)
> all languages that target LLVM (including C, C++, Fortran, Ada, Julia, Swift and others) can be used in WebAssembly.

Having LLVM doesn't mean that webassembly Just Works, in the same way that having LLVM doesn't mean that all of its architectures Just Work. And even after getting past the "hello world" stage, there's a lot of other work to do to make it more than just a toy.

Let's take Ada, for example. https://blog.adacore.com/use-of-gnat-llvm-to-translate-ada-a... talks about how to use Ada to build stuff for wasm, but you need to include https://github.com/godunko/adawebpack/ to make things work well. Someone had to write that code.

Re:Moving from TypeScript to Rust / WebAssembly by jfkebwjsbx on Thursday July 09, 2020 @11:37AM (#23781401)
No, that is if you want runtime support, etc.

If you just want to run some computational code (which is the case for most of the Wasm use today), it will Just Work, as you say.

In fact, that is how I sped up a webpage: I just wrote myself the minimal support needed to run the code that computed X, and that's it. I don't want the entire world or standard library for computational bits to work.

Re:Moving from TypeScript to Rust / WebAssembly by steveklabnik on Thursday July 09, 2020 @12:00PM (#23781642)
The example I pointed out was for extra stuff, sure, but even just to get a compiler to spit things out, work needs to be done. I don't know Ada's compiler well enough to point to where that work is, but here's the initial implementation of the asmjs and wasm targets in rustc, for example https://github.com/rust-lang/rust/pull/36339

This is just true of any architecture. LLVM is a toolkit, it isn't magic.

Re:Moving from TypeScript to Rust / WebAssembly by gboss on Wednesday July 08, 2020 @11:29PM (#23776682)
WASM doesn’t have a garbage collector built in. Languages that use a garbage collector have to also convert their language runtime into WASM which can dramatically increase the WASM file sizes and is more work to process by the browser. Since rust doesn’t have a garbage collector this should make its WASM files smaller and more performant
Re:Moving from TypeScript to Rust / WebAssembly by jkelleyrtp on Wednesday July 08, 2020 @11:26PM (#23776675)
There aren’t very many good wasm options that will produce web-friendly binary sizes. The options are really c/c++, rust, and some other less-supported languages like Zig and Nim. Rust has a good mix of high-level constructs (making it more productive than C) and has a good ecosystem around it. Cross compiling is never easy, and the rust wasm story is arguably the best and most supported via wasm-bindgen.
Re:Moving from TypeScript to Rust / WebAssembly by esperent on Wednesday July 08, 2020 @11:25PM (#23776666)
From what I understand, this mainly means that a lot of work has been put into making this process possible, while for some other languages the workflow to wasm is lacking.
Re:Moving from TypeScript to Rust / WebAssembly by fulafel on Thursday July 09, 2020 @01:09AM (#23777116)
Wasm is not memory safe inside the sandbox, so the language should enforce it if you care about correctness and/or dislike the C/C++ memory bugs and debugging.
Re:Moving from TypeScript to Rust / WebAssembly by sanxiyn on Wednesday July 08, 2020 @11:25PM (#23776664)
Mostly because WebAssembly does not include GC yet, so being a non-GC language helps.
Re:Moving from TypeScript to Rust / WebAssembly by lmm on Thursday July 09, 2020 @01:47AM (#23777282)
ML family languages are so much more productive that that probably outweighs the costs of manual memory management. Rust will always be less productive than Haskell or Scala, but a language with a decent type system is going to have a huge advantage over JavaScript.
Re:Moving from TypeScript to Rust / WebAssembly by tigershark on Thursday July 09, 2020 @02:02AM (#23777369)
...Haskell and scala are not part of the ML family. OCAML and F# are languages belonging to the ML family.
Re:Moving from TypeScript to Rust / WebAssembly by lmm on Thursday July 09, 2020 @02:23AM (#23777491)
By what definition? Haskell and Scala both have the complete ML featureset (in particular they have sum types and full pattern matching; they're also part of the small group of languages that has typeclasses, which were originally invented for Standard ML) and are on record as being heavily influenced by ML languages (via Miranda in the case of Haskell).
Re:Moving from TypeScript to Rust / WebAssembly by tigershark on Thursday July 09, 2020 @03:51AM (#23777929)
https://en.m.wikipedia.org/wiki/ML_(programming_language)

“Today there are several languages in the ML family; the three most prominent are Standard ML (SML), OCaml and F#. Ideas from ML have influenced numerous other languages, like Haskell, Cyclone, Nemerle, ATS,[citation needed] and Elm.[3]”

If you know F#, OCAML, Haskell and scala you can see that the first two have an extremely similar syntax to ML while for the last two the syntax is very different.

Re:Moving from TypeScript to Rust / WebAssembly by lmm on Thursday July 09, 2020 @05:38AM (#23778464)
If you actually click down to [3] in your own link it says '"these languages" is referring to Haskell, OCaml, SML, and F#'.
Re:Moving from TypeScript to Rust / WebAssembly by Dowwie on Thursday July 09, 2020 @11:09AM (#23781095)
An experienced Rust programmer will write generally better solutions in roughly the same amount of time as what is taken to write a solution in NodeJS, where the work is familiar. There is absolutely more code to write for a language where you can have fine control over practically everything, as long as it's within the constraints governing the compiler. However, web development consists of well-treaded paths using familiar patterns of data access and manipulation. If a new project does not benefit by code re-use, the experienced Rust programmer is going to have to use more tools and techniques to accomplish something similar in functionality to that created in other languages, but with far more guarantees and control. Who cares about guarantees and control? The team that is going to have to share the burden of maintaining the code you write.

With the patterns and libraries used in just this example, you can write a very high performance, memory efficient web server that can handle a large volume of concurrent requests that involve database interactions: https://github.com/actix/examples/tree/master/async_pg

All of the work has been consolidated down to a single file for illustration purposes, and it would usually be spread across files. Does it seem like a ridiculous amount of additional work, compared to other languages? I am misleading you some as there is actually a lot more to write the moment we move beyond plain vanilla workflows but this example proves what is possible.

Re:Moving from TypeScript to Rust / WebAssembly by yarg on Wednesday July 08, 2020 @11:14PM (#23776605)
JavaScript's a sloppier language.
Re:Moving from TypeScript to Rust / WebAssembly by empath75 on Wednesday July 08, 2020 @11:21PM (#23776638)
It’s not that bad once you get used to it.