The Zig project has also left GitHub relatively recently

https://ziglang.org/news/migrating-from-github-to-codeberg/

Thanks to both you and mi_lk, I have added zig to the list.

If you haven't already I'd check out Zig. It does what you're describing if I am understanding correctly. There are some choices in that language I find annoying, but maybe you'll still enjoy it

I've gotten into pinball the last year and also love the ones you listed. Some of the newer machines I've had a blast with include Stern's Godzilla, Ghostbusters, and 007 machines

I don't think RTO and "serious about work" are directly proportional. Some people are much more productive away from a noisy and distractive environment. I think it just depends on the person

I went back to the office recently for a day, and got literally nothing done.

Pretty much all my coworkers also reckon they are much less productive in the office.

For me it was pointers. I used C throughout college and I never really grokked the "address to a value" description, but one day it finally just clicked and now I love pointers

I'm not sure why you're being down voted. This is my exact use case as well. For what I do (front end development) it's incredibly nice to have a Linux command line for most things. I'm stuck on Windows due to legacy .NET Framework apps, so when I have to dip back into Windows I can

Most recently I think the spirit of this kind of device has been captured in the Playdate (https://play.date), but you're right that there are no new handhelds from the big companies

I actually loved Helix, but moved from it to Neovim for performance and customizability reasons. Helix becomes unusable with multi thousand line files, but I imagine it's something that will eventually be solved as the project matures. The customizability of Neovim is incredible, and I'm looking forward to trying Helix again when it has a plugin solution

Do you have an example where adding a function to the std library broke existing code? I wasn't aware this was possible

The canonical example is when a library has extended a standard trait -- adding a new trait method can cause errors due to ambiguity.

Say you had the following code:

  mod rs_std {
      pub trait StdGreetings {
          fn hello(&self) { println!("Hello!"); }
      }
  }

  use rs_std::StdGreetings;

  trait MyGreetings: rs_std::StdGreetings {
      fn good_morning(&self) { println!("Good morning!"); }
  }

  struct MyGreeter;

  impl StdGreetings for MyGreeter {}
  impl MyGreetings for MyGreeter {}

  fn main() {
      let g = MyGreeter{};
      g.hello();
      g.good_morning();
  }

This is totally valid, it'll compile, and it's not an unreasonable use case to want to extend standard traits like `io::Write`.

The problem is that a newer version of the standard library might have this:

  pub trait StdGreetings {
      fn hello(&self) { println!("Hello!"); }
      
      fn good_morning(&self) { println!("Good morning!"); }
  }

And now that existing code will fail to compile.

The Rust team's answer to this is "crater runs", where they build the current versions of all packages on crates.io with the new compiler to predict the ecosystem impact of a potential change.

> The Rust team's answer to this is "crater runs", where they build the current versions of all packages on crates.io with the new compiler to predict the ecosystem impact of a potential change.

Wow! I never knew this. What a fantastic use case for good, automatic, CI.

https://github.com/rust-lang/rust/issues/88967: they've delayed adding an `Iterator::intersperse()` method to the standard library, since it conflicts with the `Itertools::intersperse()` method from the popular `itertools` crate.

It is possible. If you implement a trait with a function “foo” on some stdlib type, then “foo” is added to the type’s inherent impl, the inherent function will now be called instead of the one in your trait when doing x.foo()

I just started looking at `vulkano` this week and have found it pleasant to work with so far. Do you have examples of high level graphics libraries that you consider poor quality?

I liked Vulkano! WGPU by contrast has a mess of an API.

Yeah I could see that. It seems nice and simple at a glance, but I remember some of the lifetime requirements being incredibly strict and hard to work with

At the high level, wgpu API follows WebGPU, which is designed by W3C.

In your criticism, are you referring to the lifetime requirements on resources used in a render pass, or something else?

Yep! And the Pods, Pins, Cows etc.