I knew that shell files, especially in build systems can get hard to read, but this was absolutely painful to look at from start to finish, even with the very helpful explanations in between. Of course the obfuscation is mostly done by design in this case.

OpenSuse Slowroll does pretty much that, a slightly delayed rolling release.

I don’t think there is a good way of having references within the same struct, but you could store reference counted matches:

matches: Vec<Rc<Match>>,
players: HashMap<String, Rc<Match>>,

You would still have to make sure that the players map is updated, maybe weak references are useful there.

Maybe you could also consider storing the players of a match in the match itself, not outside.

If there won’t be too many different plugins, maybe having a feature for each plugin would work. Then you could use --features=... when compiling to select the plugins you need.

While reading the question I thought: “That’s not how Watts work”, but then this “answer” hit…

I like to look at Issues and Pull Requests on Github if a crate wasn’t updated for multiple years. If there are already problems like unsoundness, deprecation, or breaking bugs mentioned with no reaction shown by the maintainer, that is a good sign to look elsewhere instead. If everything seems fine and the crate isn’t very complex or security-critical, it is probably not an issue.

I am also very interested in seeing what the next generation of Rust-inspired languages will look like, and not because I am dissatisfied with Rust today. Rust has significantly raised the bar of how a good programming needs to work and any new language in the systems programming area (and beyond) will inevitably be compared to it.

I really like kitty. It is fast and simple but gives me all the features I would want.

Being active is probably most important.

Maybe it would be possible to get a link into a “This Week in Rust”?

lemmy.made.me.look.at.this.each.time.i.open.a.terminal

Hostnames can be up to 64 characters long in Linux.

That’s sad that Mozilla has to take it into their own hands to provide a proper alternative to Snap Firefox.

Yeah, not gonna do that.

You’re trying to iterate over a Vec while mutating its contents in other places, which is something the borrow checker doesn’t like. Altough the later cards that get their copies count increased aren’t the same as the iterating reference card, Rust forbids two mutable references into the same Vec, even if they reference different elements of the Vec.

You could try to iterate over indices into the array instead of directly over array elements, then you get rid of the reference in the outer loop. This would probably require the least change to your code.

Another option would be to split apart the data structures between what needs to be mutated and what doesn’t. I’ve solved this puzzle in Rust and had a separate mutable Vec for the number of copies of each card. Then you can iterate over and mutate both Vecs separately without having conflicting references.

I have also switched to Colemak and my advice is to just not do that. Just learn Colemak without looking at the keyboard, it’ll make you a better typist anyway and you can get comfortable with it within a few weeks. In particular you don’t want to move the little knobs on the index finger keys (F and J).

The hexagon minecraft one is neat.

That was quite the rabbit hole, and know I know that my CPU has a bug. Great.

I still don’t see how having a flat subvolume layout would make that more problematic. You can still (even better in my opinion) choose what subvolumes to automatically snapshot, which to include in backups etc.

Yes, that seems correct to me. I would also say that the flat layout is preferable because it makes dealing with snapshots later easier. When snapshotting the rootfs subvolume you won’t have to keep track of where exactly the home subvolume is located and it is easier to boot into a different rootfs snapshot.

Hit the right arrow key once (and stop using Twitter).

man -k