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

  • Alternative Ergonomic Ref-counting RFC

    Jump

  • As someone who hasn't been following this, playing the connotation game (using "automatic" instead [partially] "implicit") is rubbing me the wrong way.

    Otherwise, the keyword use seems too generic to be used for this. But I'm sure this has been bikeshedded already, and if it hasn't, it will be.

  • Patterns for Modeling Overlapping Variant Data in Rust

    Jump

  • I only skimmed this. But my mind from the start immediately went to

      rust
        
struct CommonData {
 // common fields
}

enum VariantData {
  Variant1 {
    // Variant1 specific fields
  },
  // same for other variants
}

struct Search {
  common: CommonData,
  variant: VariantData,
}

    but I reached the end and didn't see it.

    Isn't this the way that comes to mind first for others too?

  • Artixlinux: Xlibre release 25.0.0.0 now available for testing

    Jump

  • This post is very welcome. It's sure more relevant than many posts made in this instance.

    Please continue to post whatever you like, as long as it's on-topic.

  • Showcase: Axium, an example API

    Jump

  • The uppercase A in Axium.

  • Showcase: Axium, an example API

    Jump

  • Very quickly skimmed Cargo.toml and main.rs.

    • What's with the title-case name?
    • The name proximity to axum is also not cool.
    • You should mention that this is built on top of axum in the project description.
    • How did you end up using both lazy_static and once_cell, when OnceLock has been stable since 1.70 and axum's MSRV is 1.75?
    • Why did you copy-paste min-sized-rust flags?
    • You can actually print like this:
      rust
        
println!("{proto}://{ip}:{port}");

    instead of

      rust
        
println!("{0}://{1}:{2}", proto, ip, port);

    and the positional indices are redundant anyway.

    • Since you're depending on tracing, you should actually use tracing::error instead of eprintln!("❌ ...").

    Okay. I will stop here.

  • Migrating away from Rust [gamedev]

    Jump

  • Reads okay for the most part. But I like how we see the same point about AI as a feature in some more serious real-life projects. There, we frame it as "Rust makes it harder for a 'contributor' to sneak in LLM-generated crap".

  • When I found out even Rust needed the clib, it was like seeing an iron-clad fortress only to look closer and see it was being held up by sticks, ducktape, and prayers.

    Jump

  • /mj this post was an experiment to see If I should start posting from my personal jerk archive here. But exactly as I expected and anticipated given the visibility in public feeds, this community has decent traffic, but none of the culture, or any familiarity whatsoever with the meta-ironic jerking style of the OG community. The lack of a separate meta sub/community is also not helpful since it forces users to /mj inline. But that separate community would have been public too, possibly compounding the problem.

  • When I found out even Rust needed the clib, it was like seeing an iron-clad fortress only to look closer and see it was being held up by sticks, ducktape, and prayers.

    Jump

  • It is indeed when paired with an optimizing assembler, a sophisticated static analysis tool in its own right. And just like Rust, you have greybeards hating on such provided safety because "meh it's not close to the hardware anymore", like that old man Mel.

  • When I found out even Rust needed the clib, it was like seeing an iron-clad fortress only to look closer and see it was being held up by sticks, ducktape, and prayers.

    Jump

  • we don't do xkcd here

  • [Migration post] Can you please comment here if you see this post? That will allow us to have an idea of instances that are now federated with the community.

    Jump

  • Its called fetching it.

    No. I was specifically thinking of webfinger. That's Lemmy's (ActivityPub) way of checking if an id (user or community) exists or not. Then, an instance may "read" the remote community using its outbox (if requested), and a snapshot of that remote community would now exist in the local instance. That "snapshot" doesn't get updated unless another attempt is made to view the now known remote community, AND a certain period have passed (It was 24 hours the last time I looked). In that second time, a user may actually need to make a second request (refresh/retry) to see the updates, and may need to do that after a few seconds (depending on how busy/fast instances are).

    If at least one user however subscribes to that remote community, then the remote instance live-federates all updates from that community to the subscribed user's local instance, and all these issues/complications go away.

  • [Migration post] Can you please comment here if you see this post? That will allow us to have an idea of instances that are now federated with the community.

    Jump

  • You need subscribers from instances, not views. Without subscribers, an instance may have an outdated version of your community without updates. People may see your community because someone pinged it recently, maybe via a search, and their instance grabbed your then outbox at that time.

    Ideal Federation is achieved when you have 2+ subscribers from every instance federating with your community instance. One subscriber would be enough too, but people choose to nuke there accounts sometimes, and Lemmy has the option to really erase an account as if it never existed 😉

    or whatever Lemmy calls it, haven't looked in a while.

  • Cutting Down Rust Compile Times From 30 to 2 Minutes With One Thousand Crates

    Jump

  • make uses multiple processes for parallelism, or what the blog post (below) calls "interprocess parallelism". cargo/rustc has that and intraprocess parallelism for code generation (the backend) already. the plan is to have parallelism all the way starting from the frontend. This blog post explains it all:

    https://blog.rust-lang.org/2023/11/09/parallel-rustc/

  • Cutting Down Rust Compile Times From 30 to 2 Minutes With One Thousand Crates

    Jump

  • Cool and all. But missing some experiments:

    • cranelift
    • multi-threaded rustc
    • undoing type erasure after the split
    • lto = "off"
    • strip = false (for good measure)
    • [PRIORITY] a website that works with Tridactyl✋

  • Choose peace, choose performance, choose Go

    Jump

  • ignore nulls, ignore race conditions, choose go#WebVibin' #HumoriestDev #DockerFiddler

  • Rust GUI survey 2025

    Jump

  • Oh, we got a nu-M$er here. lol.

  • Rust GUI survey 2025

    Jump

  • Along the same vein, too many open source projects don’t factor in non-“gnu/linux” environments from the start.

    No one is entitled to anything from open-source projects.

    I spent time making sure one of my public tools was cross platform once. This was pre-Rust (a C project), and before CI runners were commonly available.

    I did manage it with relative ease, but Mac/mac (what is it now?) without hardware or VMware wasn't fun (or even supported/allowed). Windows was a space hog and it's a shit non-POSIX OS created by shits anyway, and Cygwin/MSYS wouldn't have cut it for multiple reasons including performance. The three major BSDs, however, were very easy (I had prior experience with FreeBSD, but it would have been easy in any case).

    People seem to have forgotten that doing open-source was supposed to be fun first and for most. Or rather, the new generation seems to never have gotten that memo.

    POSIX is usually where a good balance between fun and public service is struck. Whether Mac/mac is included depends on the project, AND the developers involved. With CLI tools, supporting Mac/mac is often easy, especially nowadays with CI runners. With GUIs, it's more complicated/situational.

    Windows support should always be seen as charity, not an obligation, for all projects where it's not the primary target platform.

  • rustc_codegen_gcc: Progress Report #35

    Jump

  • You need to call ./y.sh prepare again

    Aha! Good to know. And yes, improved documents would be of great help.

    Thanks again for working on this.

  • rustc_codegen_gcc: Progress Report #35

    Jump

  • But running

     
        
./y.sh prepare
./y.sh test --release

    does work. That's what gave me the impression that clean all doesn't actually clean everything!

  • rustc_codegen_gcc: Progress Report #35

    Jump

  • Yeah, apologies for not communicating the issue clearly.

     
        
cp config.example.toml config.toml
./y.sh prepare
./y.sh build --sysroot
./y.sh clean all
# above commands finish with success
# below, building succeeds, but it later fails with "error: failed to load source for dependency `rustc-std-workspace-alloc`
./y.sh test --release

    And then trying to use the "release" build fails:

     
        
% CHANNEL="release"  ./y.sh cargo build  --manifest-path tests/hello-world/Cargo.toml
[BUILD] build system
    Finished `release` profile [optimized] target(s) in 0.03s
Using `/tmp/rust/rustc_codegen_gcc/build/libgccjit/d6f5a708104a98199ac0f01a3b6b279a0f7c66d3` as path for libgccjit
   Compiling mylib v0.1.0 (/tmp/rust/rustc_codegen_gcc/tests/hello-world/mylib)
error[E0463]: can't find crate for `std`
  |
  = note: the `x86_64-unknown-linux-gnu` target may not be installed
  = help: consider downloading the target with `rustup target add x86_64-unknown-linux-gnu`
  = help: consider building the standard library from source with `cargo build -Zbuild-std`

For more information about this error, try `rustc --explain E0463`.
error: could not compile `mylib` (lib) due to 1 previous error

    I will make sure to report issues directly in the future, although from account(s) not connected to this username.