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.

To piggyback off this, another reason that I think software freedom is valuable is community support. Things like LSPs, syntax highlighters, and that sort of support doesn't have to wait on JetBrains to integrate it into their IDE. I think there is real value to the community being able to hack on a tool and not being at the whim of a single developer's priorities

Except for core functionality, everything in JetBrains' IDEs is written as plugins (grammar checking, themes, support for Go/PHP/Ruby/Python/Android/framework of the month, the list goes on). You just don't notice it because of good integration with the rest of the editor (unlike how it's done in Eclipse).

Those can be (and are) developed by anybody. For example, IDEA has had absolutely the best Rust story for many years, and the Rust plugin became official only recently. It was created and developed for years before that by a single developer not affiliated with JB (and still blew all other editors out of the water).

I just adapted the intellij-rust plugin from https://github.com/intellij-rust/intellij-rust to syntax highlight Rust slightly better. It works just fine, and I had to coordinate with nobody. Just edit file, build plugin, install plugin to the IDE (using the menu in the GUI interface). That's it.

Most of the stuff of Jetbrains is open source (under Apache Software License) and is available on github.

I know what you mean though: I would never again use a closed-source IDE, or a language with closed-source standard library. Microsoft Visual Studio made me learn that, decades ago.

You can write and publish your own plugins for JetBrains IDEs.

https://plugins.jetbrains.com/

You can also sell your plugins, but it does feel less "good" to be adding value to a commercial product that you're not a part of. By that, I mean there is somewhat of a sense of community around OSS that you can't replicate within a commercial space.