jihiggins

For going from C to Rust, I think you'd just use CString::to_str instead of CString::to_string. I'm pretty sure this just calls std::transmute behind the scenes and doesn't cause an allocation. (In the same way that you generally don't clone vanilla strings and instead pass references around.) iirc, it's still tricky to go the other way. I think if I was working with super C-FFI heavy code, I'd just end up using CString as my default for that code. Custom allocators would also help there, since you could just create the strings on the stack or whatever, but I don't remember if the string version of those is even finished in nightly yet.

imo, only if it's asked in bad faith. maybe that's just worded poorly, but e.g. "oh, thanks! what'd you do differently with this recipe?" or w/e

RTO in and of itself is hostile. Especially when there is still a highly contagious disease running rampant. It might not _legally_ constitute a hostile work environment, but it is _literally_ hostile.

i remember using the falstad sim constantly at university a decade ago. super helpful and so much more intuitive than any spice thing. cool to see that it's still around and used

this is what those end up being, it's pretty straightforward?

    fn five() -> i32 {
        return 5;
    }

    fn five() -> i32 {
        5;
        return ();
    }

semicolon changes the expression from returning the result of the expression to running the expression and returning the unit type. if you accidentally do that and specified a non-unit-return-type in the function signature, the type checker tells you about it:

    error[E0308]: mismatched types
     --> src/main.rs:1:14
      |
    1 | fn test() -> i32 {
      |    ----      ^^^ expected `i32`, found `()`
      |    |
      |    implicitly returns `()` as its body has no tail or `return` expression
    2 |     5;
      |      - help: remove this semicolon to return this value

which is also pretty clear about the solution

idk there are a lot of uses for it

    let dx = {
        let prev_x = x;
        x = get_x();
        x - prev_x
    };

often, it's slightly better cpp style scoping blocks if nothing else? there are tons of other little QoL things it enables though, but they're all going to be little ergonomics things that only seem worth it if you've used the language for awhile

    let x = {
        3
    };
    let y = {
        3;
    };
    assert_eq!(x, 3);
    assert_eq!(y, ());

i think it'd also mean having to parse whitespace or newlines without something like that?

is that a problem...? should a city not prioritize its citizens over random vacationers?

it happens for me if i click start now and try to use mouse button back, but if i click the back button it works? (also latest chrome)

i think you might lose people in the transition from the turing tape machine style bootstrapping to using full "words" for operations. it might help to compare it to something like regexes? (obviously they're not similar in the way that forth / stack langs are, but they're more commonly known and more commonly thought of as useful)

i think it'd also help a lot to have some gifs of the state machine operating on stuff

or maybe you could have something with "syntax" highlighting. a navigable timeline that changes the highlighting based on the current ignore lists and / or stack contents as you step through the code could be neat

"insultingly dumb, i listen to metal" "check this out, this top 100 musician isn't mainstream so you probably haven't heard of them"

this thread's turning into a decent example of why i hate talking to people about music. no matter how polite or reasonable someone is otherwise, there's like a 90% chance they have all these weird value judgements tied up in what people are listening to. it's incredibly tedious.

he has several albums that have been #1 on various billboard charts, if that's not mainstream then idk what is

this is sort of what modern ides (e.g. jetbrains stuff) already do in the bg. when im working on stuff, i almost never navigate via text or the file explorer, i use things like "goto usages or definition" and navigate via what is essentially data tracing. this only works well with statically typed languages ime, though.

the indexing step is basically building this db in the background, it's just kept out of view / hidden unless you're building ide plugins or whatever.