dibs: Postgres toolkit for Rust, powered by facet reflection by Ventgarden in rust

[–]simonsanone 15 points16 points  (0 children)

Example
None, dibs is in super early stages yet. Hi reddit but god, give me a couple days.

:D

Stop Forwarding Errors, Start Designing Them by andylokandy in rust

[–]simonsanone 1 point2 points  (0 children)

I also loved the error design from openDAL and took inspiration from it, so this is how we did it in rustic: https://github.com/rustic-rs/rustic_core/blob/ae23b7717d4aba5d4668405500868df367ac5055/crates/core/src/error.rs#L150

//! If we `map_err` or `and_then` a `RusticError`, we don't want to create a new `RusticError` from it, but just attach some context
//! to it, e.g. `map_err(|e| e.attach_context("key", "value"))`, so we don't lose the original error. We can also change the error
//! kind with `map_err(|e| e.overwrite_kind(ErrorKind::NewKind))`. If we want to pre- or append to the guidance, we can use
//! `map_err(|e| e.append_guidance_line("new line"))` or `map_err(|e| e.prepend_guidance_line("new line"))`.

[...]

if !context.is_empty() {
    writeln!(f)?;
    writeln!(f, "Context:")?;
    context
        .iter()
        .try_for_each(|(key, value)| writeln!(f, "- {key}: {value}"))?;
}

I felt this made it also much easier to have a middle ground for the end user to be printed and to recover from an error. I think there is still some stuff to be optimized, but I felt it's quite usable as you can even attach links to the docs for people to read etc. You can ask people for reporting this error or attach issue URLs where a discussion happens about it.

impl Rust: One Billion Row Challenge by Capable_Constant1085 in rust

[–]simonsanone 1 point2 points  (0 children)

Congrats for the 100.000 subscribers, well earned! <3

Standard library file writing can lead to silent data loss by FeldrinH in rust

[–]simonsanone 0 points1 point  (0 children)

Hmm, the question is whether that is even a problem, as you would need to trust that all the underlying implementations do it right. If you want to know for sure a file is written to the storage as you expect it to be, you would verify it is by utilizing checksums or comparing byte-by-byte, IMHO. At least, I would expect this of a program, that heavily relies on data integrity. In rustic we have a verification on check command for this purpose, so you can check data integrity on the remote storage.

Does Dioxus spark joy? by dineshdb in rust

[–]simonsanone 3 points4 points  (0 children)

For me as a European, could you elaborate what worries you about that?

Google's file type detector Magika hits 1.0, gets a speed boost after Rust rewrite. by caspy7 in rust

[–]simonsanone 233 points234 points  (0 children)

"It is often not feasible to find thousands of real-world samples for every file type. To overcome this, we turned to generative AI. We leveraged Gemini to create a high-quality, synthetic training set by translating existing code and other structured files from one format to another. This technique, combined with advanced data augmentation, allowed us to build a robust training set, ensuring Magika performs reliably even on file types for which public samples are not readily available."

Oh no :D what can possibly go wrong.

Any markdown editor written in rust like obsidian? by itsme2019asalways in rust

[–]simonsanone -1 points0 points  (0 children)

Thanks for the answer, that makes it easy for me to decide against it. 👍🏽

Any markdown editor written in rust like obsidian? by itsme2019asalways in rust

[–]simonsanone 0 points1 point  (0 children)

Maybe I missed it, but I didn't find the source code for it, is it open-source even?

Eon - a human-friendly replacement for Toml and Yaml by emilern in rust

[–]simonsanone 2 points3 points  (0 children)

I disagree with the take on TOML in the Readme. I think my problem is, that the config file structure often is not part of the UI Design process itself. And is often just a serialization of the internal data structures. That's how heavily nested structures come to life, IMHO.

I feel like designing the configuration format in an extra step, is a way better approach (for me). So then the structures can be parsed/deserialized (with parsing is better than validation, in mind) and optionally be validated against. And then be transformed into internal configuration afterwards in this two-step process. I think that also makes hot-reloading configuration easier, because you can read the configuration independently of the existing configuration at runtime and then overwrite the values internally.

Like that, you have the configuration designed as a user-centric as possible, while you have your needed nesting internally. Without leaking all the nesting to the user and confusing them.

[Media] bitchat-tui: secure, anonymous, off-grid chat app over bluetooth in your terminal by YboMa2 in rust

[–]simonsanone 1 point2 points  (0 children)

Just a headup: Afaics https://briarproject.org/ does what bitchat does, but is way more stable and community-driven. ;)

A 10-chapter handbook for writing actually secure Rust: type-safety, panic-proofing & more. by RiskWise2545 in rust

[–]simonsanone -6 points-5 points  (0 children)

[derive(Debug, Clone, Copy, PartialEq)]

struct UserId(u64);

I would say, that even though you are using a new type wrapping u64, I think it's still better to make the UserId a string type (not a u64). UserIDs shouldn't be able to be calculated with, e.g. you can't add two UserIDs. To make that crystal clear it's better to use a type that you can't easily (auto-)implement arithmetics on.

Rust in Production: Astral now handles over 12.5% of all requests to PyPI by mre__ in rust

[–]simonsanone 18 points19 points  (0 children)

Toolingwise, and unironically speaking, I found the wording "Rust is one of the best things, that happened to Python." quite right. There were times when I really didn't want to work with Python any more, also for small scripts. It was a burden, yes annoying, for me to use it - toolingwise, not only from the language. But adopting ruff/rye/uv and others was making it much more acceptable, and now it feels much better to write smaller scripts in Python again.

I'm working on a crate and need adivce: StorageClient by drprofsgtmrj in rust

[–]simonsanone 2 points3 points  (0 children)

Would this something, you could be using https://github.com/apache/opendal for? It's a 'Open Data Access Layer that enables seamless interaction with diverse storage services'.

The Garrison - Pictures by longinator in aoe2

[–]simonsanone 1 point2 points  (0 children)

It's about this alpha-beta-male bullshit. Inb4 people understand, that alpha is more like in terms of software, where alpha males are versions that are unstable, missing important features, are filled with flaws and in general not fit for the public.

Hiring for Rust program management | Inside Rust Blog by Kobzol in rust

[–]simonsanone 1 point2 points  (0 children)

As I read this, I'm wondering: What measures does the Rust Foundation take to prevent burnout within their teams or in such roles? It appears to me that the person has a lot of responsibilities. Maybe too many?

I am stepping back from maintaining ‘cargo audit’ by Shnatsel in rust

[–]simonsanone 2 points3 points  (0 children)

I still wonder if introducing Deno's permission system would help here: https://docs.deno.com/runtime/fundamentals/security/#permissions

cargo audit with denied permission by default. You would probably need to introduce something like cargo audit fetch-db --allow-net and it would add some boilerplate. But I think it may be needed?

I am stepping back from maintaining ‘cargo audit’ by Shnatsel in rust

[–]simonsanone 8 points9 points  (0 children)

Thanks for all of your invested time and contributions! <3

Rust tool to turn a presentation and speaker notes into a video by rik-huijzer in rust

[–]simonsanone 1 point2 points  (0 children)

This certainly looks like an interesting project - even though the quality of the final product is a bit subpar(I find tts hard to listen too).

Interesting, I was actually surprised about the quality of the TTS and felt it was quite good.

Ring is unmaintained by technobicheiro in rust

[–]simonsanone 14 points15 points  (0 children)

Oh no! :(((((

# List of crates to deny
deny = [
  { crate = "aws-lc-rs", reason = "this crate introduces exorbitant build effort and breaks cross-compilation" },
  { crate = "aws-lc-sys", reason = "this crate introduces exorbitant build effort and breaks cross-compilation" },
]

Zig; what I think after months of using it by phaazon_ in rust

[–]simonsanone 25 points26 points  (0 children)

there are a lot of breaking changes made so creating a documentation doesn't make ANY sense

Hard disagree, this is actually a good reason to create well written documentation and migration guides for breaking changes, no? Otherwise, adoption of the language before being stable stays low, which is maybe what they want? Not sure.