I think embedded Rust is simply really really new, and requires interacting with crusty C tools which is going to reduce reliability.

It’s also a little fragmented with people trying different things out (e.g. Embassy vs RTIC), and different chips getting different levels of support.

Totally different experience to desktop development.

1. If your alternative is C++ then it removes the enormous burden of manually tracking lifetimes and doing manual memory management. C++ does have RAII which helps with that enormously but even then there are a gazillion footguns that Rust just doesn’t have - especially with the newer stuff like rvalue references, std::move, coroutines etc. It also saves you from C++'s dreaded undefined behaviour which is everywhere.

2. It has a very strong (and nicely designed) type system which gives an “if it compiles it works” kind of feel, similar to FP languages like Haskell (so they say anyway; I’ve not used it enough to know). The borrow checker strongly pushes you to write code in a style that somehow leads to less buggy code. More compiler errors, but much less debugging and fixing bugs.

3. The libraries and APIs are generally very well designed and nice to use. If you’ve ever used Dart or Go think how nice the standard library is compared to JavaScript or PHP. It took C++ like 2 decades to get string::starts_with but Rust started with it (and much more!).

4. Fast by default.

5. Modern tooling. No project setup hassle.

6. It’s a value based language, not reference based. References are explicit unlike JavaScript, Java, C#, etc. This is much nicer and makes things like e.g. copying values a lot easier. JavaScript’s answer for ages was “serialise to JSON and back” which is crazy.

Downsides:

1. Slow compilation sometimes. I’d say it’s on par with C++ these days.

2. Async Rust is kind of a mess. They shipped an MVP and it’s still kind of hard to use and has unexpected footguns, which is a shame because sync Rust avoids footguns so well. Avoid async Rust if you can. Unfortunately sometimes you can’t.

3. Interop with C++ is somewhat painful because Rust doesn’t have move constructors.

Great language overall. Probably the best at the moment.

No because it doesn’t remotely take that long.

Sure, but it’s very similar. The point is that those people didn’t get to choose the language they’re using and now someone is forcing them to use a specific language. They’ve always been forced to use a specific language.

I guess it just think “I don’t want to learn” is a lame excuse.

That’s a lot easily than learning the C to the same level and they “force” everyone to learn C.

Right but presumably you can let the AI do that hunting.

Gemini has a 1 million token limit. Also instead of just giving it the entire source you can give it a list of files and the ability to query them (e.g. to read an entire file, or search for usages/definitions of terms etc.).

No but I think this is probably a great use case for AI. Haven’t tried it though.

you can write perfectly safe software in it.

In the same way that you can safely walk through a minefield.

I dunno what you mean about it being an expressive language either. I would say it is relatively low on the expressiveness scale compared to something like Python or OCaml. It’s basically as expensive as Go which is renowned for being unexpressive. Maybe you didn’t mean “expressive”.

It doesn’t look like it would be hard to have (comment “foo bar baz”) in an expression

That is pretty much what the official “solution” is for comments in package.json - add "//": "foo bar baz" keys to dictionaries and NPM will ignore them.

In practice it’s terrible. You need real comments.

One nice thing about XML is that there’s an official way to link to the schema from within the document. If you do that you can easily automatically validate it, and even better you get fantastic IDE support via Red Hat’s LSP server. Live validation, hover for keys, etc.

It’s a really nice experience and JSON schema can’t really match it.

That said, XML just has the wrong data model for 99% of use cases.

That appears to not support comments. How they made that mistake after JSON is a mystery.

Would you rather build from wood or tissue paper?

What glue is better: 2 part epoxy or pritt stick?

Do you prefer soap or ash as a cleaning agent?

Sure there aren’t many things that are universally loved. I mean I can’t really think of anything that doesn’t have some flaw.

But that doesn’t mean everything is equal! What would you rather program with, Visual Basic or Go? PHP or Typescript? If you polled people there are obvious winners.

Think of it from the company’s point of view. If you’re hiring a new employee then the options for a good candidate are a) move jobs and work for you, b) move jobs and work for someone else. You’re competing with other companies.

If you’re reviewing an existing salary for a good employee their options are a) do nothing and accept the shitty raise, b) move jobs and work for someone else.

Moving jobs has significant cost for most people - it’s time consuming, stressful, might involve moving house, etc.

That downside gives employees who haven’t proven they are looking for a new job a significant negotiating disadvantage.

If you really want you can tell your boss you are actively looking for new jobs. That will increase your chances of getting a bigger raise, but of course it has other downsides so most people don’t do that.

Rust is the obvious answer, though I dunno how suitable it really is for games - the most popular game engine is Bevy and I’m not sure I like it too much. Also there seems to be much more focus on game technology than making actual games.

Don’t worry about it being “functional” though. It did support lots of FP features but the typical style is much more like imperative C++ than Haskell.

I would also look into Zig though.

Languages that make use of references rather than pointers don’t have this Dualism.

It’s not about references vs pointers. You could easily have a language that allowed “null references” (edit: too much C++; of course many languages allow null references, e.g. Javascript) or one that properly separated null pointers out in the type system.

I agree with your point though, using a special Null value is usually worse than using Option or similar. And nullptr_t doesn’t help with this at all.

I agree Bluetooth (at least Bluetooth Classic) is not very well designed, but not because of frequency hopping. That improves robustness and I don’t see why it would cost any more power. The hopping pattern is deterministic. Receivers know in advance which frequency to hop to.

The biggest problems with gRPC are:

1. Very complicated. Way more complexity than you want in most cases.
2. Depends on HTTP 2. I’ve seen people who weren’t even doing web stuff reach for gRPC, and now boom you have a web server in your stack for now reason. Compare to Thrift which properly separates out encodings, transports, etc.
3. Doesn’t work from the web. There are actually two modifications to gRPC to make it work on the web which means you have three different incompatible versions of gRPC with different feature sets. IIRC some of them require setting up complex proxies, some don’t support streaming calls, ugh. Total mess.

Plain HTTP can be type safe. Just publish JSON schema or Typespec files or even use Protobuf.

TOML is not a very good format IMO. It’s fine for very simple config structures, but as soon as you have any level of nesting at all it becomes an unobvious mess. Worse than YAML even.

What is this even?

[[fruits]]
name = "apple"

[fruits.physical]
color = "red"
shape = "round"

[[fruits.varieties]]
name = "red delicious"

[[fruits.varieties]]
name = "granny smith"

[[fruits]]
name = "banana"

[[fruits.varieties]]
name = "plantain"

That’s an example from the docs, and I have literally no idea what structure it makes. Compare to the JSON which is far more obvious:

{
  "fruits": [
    {
      "name": "apple",
      "physical": {
        "color": "red",
        "shape": "round"
      },
      "varieties": [
        { "name": "red delicious" },
        { "name": "granny smith" }
      ]
    },
    {
      "name": "banana",
      "varieties": [
        { "name": "plantain" }
      ]
    }
  ]
}

The fact that they have to explain the structure by showing you the corresponding JSON says a lot.

JSON5 is much better IMO. Unfortunately it isn’t as popular and doesn’t have as much ecosystem support.