News for hackers. Stuff that matters.
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.