With GPU rendering, you should learn about GPU processing and memory usage too, not that it would matter much for such a use-case.

nvtop is nice for displaying all that info (it’s not nvidia-specific).

Also % CPU usage is not a good metric, especially when most people forget to set CPU frequencies to fixed values before measuring. And heterogenous architectures (e.g. big.LITTLE) make such numbers meaningless anyway (without additional context). But again, none of this really matters in this use-case.

A quick shallow look.

• Avoid single hard paths. Provide fall-backs. Make them all configurable. Use xdg (properly)…etc.
• Avoid .unwrap() or any source of panic!() for non-fatal things that can actually fail.
• Make non strictly necessary fields optional in you model, if that helps.
• Use .filter_map() and .collect() in your parsing code, instead of all the matches and continues in a for loop. You can use .ok()? to early-return with None on errors.
• And finally, since you’re micro-benchmarking, try speedy or borsh instead of bincode, unless you need the serde compat for some reason.

I get it – abstractions are cool. They’re supposed to hide complexity so we can focus on cooler stuff. And Rust loves that idea. Traits, generics, lifetimes – layer upon layer of “don’t worry about it honey.”

That’s such a fundamental misunderstanding of something so basic, that I almost had to stop reading.

Generally yes, unless it’s the original source of a story.
e-celeb content and news aggregators are never the original source of a story.

That some can and already do that on the video sites they already browse.

People like shorts too, but that doesn’t mean Lemmy should be infested with such content.

We went from spam “news sites” to spam videos. Maybe an “original source” policy should be applied by moderators!

This applies to both hare and on !rust@programming.dev

That’s exactly the communicated meaning I was concerned an oblivious reader might get. You can use an updated Rust compiler 10 years in the future while your crate is still on 2015/2018/2021 edition. Editions are NOT software versions.

I might expect the Rust ecosystem to adopt these new features.

This again points to you maybe not understanding how editions work, or maybe I’m just reading it wrong again. But you “upgrading” has no effect on your dependencies, and vise versa (except indirectly if MSRV is a factor as another user mentioned).

Just upgraded

Weird wording!
Maybe it’s just me, but this may give the impression that it’s something that is strictly needed, or will provide any immediate improvement, which is not the case, unless you’re still actively working on these projects and plan to use/depend on features/behaviors required by the new edition.

Is there a tiling Wayland compositor out there that supports applying custom shaders to windows (similar to picom)? This has been a known limitation for many years. And I brought it up myself with a couple of compositors’ developers, and they told me that it would break direct scan-out, and I told them that I would be fine with that, and then discussions fizzled out.

I also tried an x11vnc alternative I don’t remember the name of, and besides the generally buggy experience, it completely broke when power management kicked on the sever side (turning off the monitor IIRC). So that’s another show stopper, although maybe not as relevant as custom shader support which I need for applying my custom color inversion shaders to specific windows, otherwise, my vision would go bad quickly.

So yeah, I will be sticking with my Awesome WM (+picom +x11vnc) setup for a while too.

Since cargo-edit broke

Sparse indices support got added in last September. A perma-WIP pull request that added support for them existed for much longer.

The most important part of curl is the library, not the CLI tool. And the TLS backend is very much relevant due to varying features supported, different licenses involved, and varying levels of ease when it comes to building and distribution.

That’s when you’re providing binaries. Otherwise, you would have to be wary of potential compatibility issues with libcurl packages provided by different Linux distributions for example.

See CURLOPT_ECH for a recent and still evolving example of this.

Another huh from me. Or maybe I’m missing something, because this should all be obvious.

The source of the standard library is a rustup component that everyone should have installed. As for crates, you don’t have to manually download any sources. Just add the crate as a dependency, and jump around definitions as much as you like. You can remove the dependency later if you decide to not use it.

this wasn’t easy for me to find

Huh! This is the internal ExitCode, and it’s two jump-to-definition calls away. The first to get to the public type definition, and the second from the public type’s struct field to the private type.

ExitCode is a struct, therefore it behaves like a type with many fields which define the types contained in the struct.

That’s a bit too off. structs in rust are product types. A struct may define zero or more fields. And fields can be named or not. if not, such structs are called tuple structs.

In the doc page, if you clicked on source, it would have taken you to the definition.

pub struct ExitCode(imp::ExitCode);

That’s a public struct with one unnamed private field. The type of the private field also happens to be private/internal.

As for why, usually the purpose is providing type safety, a unified interface,… etc. Notice how for example a windows-only extension trait is implemented that allows converting raw u32 exit codes into ExitCode.

So now you have exit codes possibly sourced from u8 or u32 values depending on the platform. And you need a safe unified interface to represent them.

I hope that’s an enough starting point.

I would move all struct members from Foo<false> into a “new” Foo<true> and return that?

Yes… if you don’t define Drop for Foo.

If you do, then you will have to either use mem::take()/mem::replace() with each field, or if you don’t mind unsafe {}, you can just do a trivial transmute. Justunsafe { transmute(self) } should work.

I’m stating the obvious here, but if you have ownership at the time of conversion, then you can just change the type, you don’t have to use dyn (a la impl Foo<false> { fn into_debug(self) -> Foo<true> {} }). That may require some code restructuring of course.

Yeah, I got that.

I’m asking what would be the benefit of not using a single error enum for all failure reasons?

use-case?

It’s quite simple. Just remove the permalink field! If you are calculating it then no need to store it in the struct.

This is inefficient. It should be the other way around. Remove base_url and rel_permalink, and store permalink and the rel_permalink offset.

That way, you can get a zero cost &str for any of the three.