2024-03-29                         from the editor of ~insom
   ------------------------------------------------------------

   I posted on Mastodon about feeling how I should get back
   into Rust, not because I like it (I don't) but because it
   seems like the only viable language for unifying all the
   kinds of software I write (web, system, embedded) while
   maybe being more suitable for "real" production than the
   kind of C that I write (buggy :p).

   I've done a little trivial embedded stuff with Rust and so
   far I'm really hating it! Some of it is just being
   unfamiliar with the language and I am not being fair by
   trying to do a non-mainstream kind of development with it
   while not being very versed in Rust to begin with.

   But the other part, I think, is the ecosystem. There's a
   maze of crates you can use to get things done, and they are
   at various levels of compatibility with each other and with
   the Rust compiler itself. This isn't the language's fault:
   no one forced me to add a dependency, but looking at the
   transitive graph of dependencies it seems like
   almost-leftpad-levels of dependency is here, at least in the
   embedded crates.

   For the embedded libraries I've tried using (the
   `rp2040_hal`, part of the `embedded_hal` ecosystem) a large
   amount of the implementation is written by macros, which are
   kind-of inscrutable for a relative beginner like me, and
   lead to me being unable to find the definition of things
   without getting the IDE to help me. This is very familiar
   from my days of Rails programming, and one thing that's
   basically impossible in Go and that has made me _enjoy_
   writing Go. You just can't be _that_ clever in Go.

   I don't think you _have_ to be that clever in Rust, either,
   but I think there's people out there who enjoy it (good for
   them: I am getting their work for free, they should enjoy
   doing it) -- and as a user in the ecosystem you're
   immediately slammed into decisions about blocking vs.
   polling vs. async versions of APIs and crates the depend on
   one (or other) of these implementations.

   idk. I guess this another rant. I'd like it to be something
   I look back on in a year, when I have reached Rust
   transcendance, and laugh at my naivity. I will perservere.