Rust is Eating JavaScript

[commander@lemmings.world]

Good!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

[commander@lemmings.world]

I agree.

I'm noticing this species has a problem with doing things the obviously correct way the first time.

It's as though we'd rather put 100x more effort for 10% of the results just to prove that we "can" do it.

[brodysseus@lemmy.dbzer0.com]

I'm currently an underclassman and my OS class has a few assignments that let you choose to use c or rust. You convinced me to try rust

[orygin@sh.itjust.works]

Not sure if that's what you are referring to as destructors, but they added a new way to have code run at resource collection in go 1.24

[mostlikelyaperson@lemmy.world]

Originally 4 years old at this point it looks like, and the great shift to wasm has failed to manifest.

[chopsteeq@lemmy.ml]

Hell yes! That was the point of my rambling though I never quite got there. I was wondering if curriculums had caught up yet, to at least look at the modern system languages. Sounds like you’re at a good program.

[balder1991@lemmy.world]

Not all of the stdlib is written in C. Some parts cannot be Python because it’s critical code that needs to be as fast as possible.

Python is already slow for many use cases, if the standard lib was all built in Python it would be just too slow for much more use cases.

[sugar_in_your_tea@sh.itjust.works]

I assume you're talking about runtime. AddCleanup()? That's certainly nice, but it's not the same as a destructor since it only runs at GC time. It's useful for cleaning up data used by a shared library or something (e.g. something malloc'd by a C lib), but it only solves part of the problem.

I'm talking about scope guards. In Rust, here's how you deal with mutexes:

{
    let value = mutex.Lock();
    ... use value ...
    // mutex.Unlock() automatically called
} 

The closest thing in Go is defer():

mutex.Lock()
defer mutex.Unlock()

That works most of the time, but it doesn't handle more complex use cases, like selectively unlocking a mutex early while still guaranteeing it eventually gets unlocked.

Rust fixes this with the Drop trait, so basically I can drop something early conditionally, but it'll get dropped automatically when going out of scope. For example:

struct A(String);

impl Drop for A {
    fn drop(&mut self) {
        println!("dropping {}", self.0)
    }
}

fn main() {
    let a = A("a".into());
    let b = A("b".into());
    let c = A("c".into());
    drop(b);
}

Without the last line, this prints c, b, a, i.e. stack order. With the last line, it instead prints b, c, a, because I drop b early.

This is incredibly useful when dealing with complex logic, especially with mutexes, because it allows you to cleanly and correctly handle edge cases. Things are dropped at block scope too, giving even more control of semantically releasing things like locks.

That said, 1.24 added WASM, which is really cool, so thanks for encouraging me to look at the release notes.

[bogasse@lemmy.ml]

I didn't mean it's a bad choice !

But I think it's a good example of the compromise that has to be made here : what's the best fitting technology vs. how to ensure easy onboarding for future contributors.

[curry@programming.dev]

[Screams internally]

[thrashy@lemmy.world]

Look, I'm in no position to talk seeing as I once wrote a shell script in PHP, but the profusion of JavaScript in the late aughts and early teens for things that weren't "make my website prettier!" feels very much like a bunch of "webmasters" dealing with the fact that the job market had shifted out from under them while they weren't looking and rebranding as "developers" whose only tool was Hammer.js, and thinking all their problems could be recontextualized as Nail.js.

[zaphod@sopuli.xyz]

It was recently shared on Hackernews, I assume that's why it's showing up here now.

[greenknight23@lemmy.world]

lmao.

rust seems pretty desperate to remain relevant.

"rust is replacing c"
"rust is replacing the Linux kernel"
"rust is replacing javascript"
"rust is replacing your mom"

[andallthat@lemmy.world]

well, joke's on you. Since I rewrote her in Rust, my mum runs the 100 meters hurdles in 14 seconds

[zykino@programming.dev]

3. Is a modern language with a good build system (It's like night and day compared to CMake)

Meson exists ... as do others.

But they are not the default option. And your new job may not use them.

4. And I just like how the language works (errors as values etc.)

Fair enough; though why? What's wrong with exceptions?

Exceptions is a non standard exit point. And by "non standard" I'm not talking about the language but about its surprise appearance not specified in the prototype. Calling double foo(); you don't know if you should try/catch it, against which exceptions, is it an internal function that may throw 10 level deep ?

By contrast fn foo() -> Result<f64, Error> in rRst tell you the function may fail. You can inspect the error type if you want to handle it. But the true power of Result in Rust (and Option) is that you have a lot of ergonomic ways to handle the bad case and you are forced to plan for it so you cannot use a bad value thinking it's good:

• foo().unwrap() panic in case of error (see also expect)
• foo().unwrap_or_default() to ignore the error and continue the happy path with 0.0
• foo().unwrap_or(13.37) to use your default
• foo()? to return with the error and let the parent handle it, maybe

[orygin@sh.itjust.works]

Thanks for taking the time to explain it. Indeed the new runtime method does not guarantee when the resource will be cleaned, so something like that Drop trait would be quite useful

[tzrlk@lemmy.world]

That sounds a lot like how checked exceptions work, though with some terser handling syntax.

[bamboo@lemm.ee]

What exactly are the hazards of shared memory and locks? The ownership system and the borrow checker do a pretty good job at enforcing correct usage, and if you are clever you can even guarantee no deadlocks (talk at rustconf 2024 about the fuchsia network stack).

[dark_arc@social.packetloss.gg]

But they are not the default option. And your new job may not use them.

Who cares if it's the default? If it's the best tool, use it.

It's to have a reason for "going Rust" be the build system, especially in the context of something as new as a WASM context where basically any project is going to be green field or green field adjacent.

Exceptions is a non standard exit point. And by "non standard" I'm not talking about the language but about its surprise appearance not specified in the prototype. Calling double foo(); you don't know if you should try/catch it, against which exceptions, is it an internal function that may throw 10 level deep ?

And that's a feature not a bug; it gets incredibly tedious to unwrap or forward manually at every level.

By contrast fn foo() -> Result<f64, Error> in rRst tell you the function may fail. You can inspect the error type if you want to handle it. But the true power of Result in Rust (and Option) is that you have a lot of ergonomic ways to handle the bad case and you are forced to plan for it so you cannot use a bad value thinking it's good:

You can do this in C++ https://en.cppreference.com/w/cpp/utility/expected (and as I said, if you feel so inclined, turn off exceptions entirely); it's just not the "usual" way of doing things.

[zykino@programming.dev]

First time I hear about checked exceptions. How do you use them ? Are you forced to handle them explicitly ? Is the handling checked at compile time ?