Skip Navigation

InitialsDiceBearhttps://github.com/dicebear/dicebearhttps://creativecommons.org/publicdomain/zero/1.0/„Initials” (https://github.com/dicebear/dicebear) by „DiceBear”, licensed under „CC0 1.0” (https://creativecommons.org/publicdomain/zero/1.0/)B

BB_C

@ BB_C @programming.dev

Posts
10
Comments
375
Joined
2 yr. ago

  • Rust is rolling off the Volvo assembly line - Blog - Tweede golf

    Jump

  • all the equivalent functionality and how to translate existing concepts over from one language to the other.

    Antithetical would be the word to describe this, I think. Although I've seen such titled content.

  • Getting debugger setup in VSCode

    Jump
    • Why do you think this is a debugger issue?
    • May I suggest you try to learn how to use the rust toolchain directly first?
    • The error message looks informative to me. What part of this line did you not get?
       
          
 either src/lib.rs, src/main.rs, a [lib] section, or [[bin]] section must be present

    I think you're tying yourself too close to VSCode. Reading this Cargo guide is a minimal requirement. And you should learn how to use cargo (the command), at least for basic operations. This is not hard. If anything, it's much simpler than those bloated and opaque editor/IDE setups.

  • Zig vs Rust. Which one is going to be future?

    Jump

  • 🤣

    I don't know, and I don't want to get personal. But that's usually a sign of someone who doesn't even code (at non-trivial levels at least), and thinks programming languages are like sport clubs, developers are like players contracted to play for one and only one club, and every person in the internet gantry need to, for some reason, pick one club (and one club only) to be a fanboy of. Some people even center their whole personality around such fanboyism, and maybe even venture into fanaticism.

    So each X vs Y language discussion in the mind of such a person is a pre-game or a pre-season discussion, where the game or season is an imaginary competition such people fully concoct in their minds, a competition that X or Y will eventually and decidedly "win".

    Maybe that was an exaggeration on my part. Some junior developers probably fall into these traps too, although one might expect, or maybe hope, that their view wouldn't be that detached from reality.

    I'm hoping to finally finish and send out a delayed new release for one of my older and mature CLI tools this weekend. It's written in C btw 😄

  • Zig vs Rust. Which one is going to be future?

    Jump

  • I hope that someone in the 40 comments i don't have time to read right now has pointed out that the premise of OP is flawed for the simple reason that Rust hit v1.0 in 2015, while Zig is still nowhere near that milestone in 2024.

    So we are not even talking about the same "future" period from the start.

    So, no need to get to the second false premise in OP, which is limiting a "future" period to one successful dominating language only. Nor is there a need to go beyond these premises and discuss actual language details/features.

  • Code Generation in Rust vs C++26

    Jump

  • Not only that. We don't just "inject" raw strings with the syn/quote duality. Stringified or not, the token tree will be parse-checked into the expected syn type before being used in generated code.

    So the distinction is both wrong and irrelevant. This is what I meant by wrong on multiple levels/layers 😉

  • Code Generation in Rust vs C++26

    Jump

  • In Rust, you provide a string — that is injected to be invoked internally. In C++, we’d just provide a callable.

    This is because Rust’s attribute grammar can’t support a callable here.

    I don't do C++ as a life choice, and thus not 100% sure what the author means here. But I have the feeling that he is wrong, on multiple levels even 😉

  • GitHub - RReverser/serdebug: Serde-based replacement for #[derive(Debug)]

    Jump

  • I just looked at the code, and it's actually a neat idea implementation wise, and I see now how it helped you.

    But I'm still of the opinion that its a purpose mismatch.

  • GitHub - RReverser/serdebug: Serde-based replacement for #[derive(Debug)]

    Jump

  • Last week I basically duplicated the serialization code to provide better debug output…

    Why was duplication needed, instead of implementing Debug using serialized output?

    And why would one want to rename stuff...etc in Debug anyway? It's for debugging?

    This looks like purpose mismatch to me.

  • “Truly Hygienic” Let Statements in Rust

    Jump

  • Also:

    A short post on how variable names can leak out of macros

    I don't think you understood the blog OP!

  • “Truly Hygienic” Let Statements in Rust

    Jump

  • Maybe a good idea for a post. But the amount of reaches required makes this icky.

    • Pretending people write:
        rust
          
let Ok(x) = read_input() else { return Err(Error) };
      instead of
        rust
          
 let x = read_input().map_err(|_| ...)?;
    • Pretending people write:
        rust
          
 const x: &str = "...";
      instead of
        rust
          
 const X: &str = "...";
    • Pretending there exist people who have such knowledge of rust macros hygiene, ident namespaces, etc, but somehow don't know about how macro code expands (the "shock" about the compile error).

    Maybe there is a reason after all why almost no one (maybe no one, period) was ever in that situation.

  • [newbie] one-liner to avoid "temporary value dropped while borrowed"?

    Jump

  • you’re not supposed to immediately reach for macros

    correct

    for small things you don’t quite like about the language.

    incorrect

    Excessive macro use makes it impossible for others (including your future self) to read your code

    N/A. the macro above is trivial.

    impossible for others to read your code and there’s often good reasons why it’s designed like it is.

    fiction

  • [newbie] one-liner to avoid "temporary value dropped while borrowed"?

    Jump

  • There is a general mechanism in Rust that allows language users to add their own sugar. It's called macros 😉 

      rust
        
macro_rules! keep {
    (let $id:ident = $expr:expr => $($tt:tt)+) => {
        let $id = $expr;
        let $id = $id$($tt)+;
    }
}

fn main() {
    keep!{ let path = std::env::current_dir().unwrap() => .as_path() };
    println!("{path:?}");
}

    You can remove let from the macro's fragment specifier and invocation.

  • Understanding Rust Ownership: Immutable and Mutable References, RC and RefCell

    Jump

  • mastering_rust

    Maybe wait until you're actually good at it.

  • Which code style to initialize structs?

    Jump

  • Rebinding with and without mut is a known and encouraged pattern in rust. Leaving things as mut longer than necessary is not.

  • Reviving the devtools support in Servo - Servo, the embeddable, independent, memory-safe, modular, parallel web rendering engine

    Jump

  • Bringing vimperator/pentadactyl back! That would be the dream.

    Anyway, last time I tested it (~3 weeks ago), servo was not very usable still with the few websites I tried. Hopefully it gets, at least partway, there in a few months.

  • Which code style to initialize structs?

    Jump

  • Neither.

    • make new() give you a fully valid and usable struct value.
    • or use a builder (you can call it something else like Partial/Incomplete/whatever) struct so you can't accidentally do anything without a fully initialized value.

    Maybe you should also use substructs that hold some of the info.

  • Arch user trying out lightweight desktop environments

    Jump

  • If you're not into tiling, install openbox and a panel of your choosing. You will quickly find that you don't need a DE at all.

  • Confused about linux as always

    Jump

  • The maintenance is too high.

    acquired knowledge spotted

  • Confused about linux as always

    Jump

  • I will let you on a little secret.

    The best "support" you can get is support from upstreams directly (I'm involved in both sides of that equation). But upstreams will often only "support" you when you 1. run the latest stable version 2. the upstream source code wasn't patched willy-nilly by the packager (your distro).

    So the best desktop linux experience comes with using rolling distro that gives you such packages, with Arch being the most prominent example.

    The acquired knowledge that argues stability and tells you otherwise is a meme.