Hacker News Reader

Comment by AlexanderDhoore | Hacker News Reader

I really hope embedded rust can become the next rock-solid foundation. I need my code to build/run today and also in 10 years. We have code in our codebase from at least the early 90s but I suspect it's older than that.

I went into embedded because I really despise the code churn of higher level frameworks/languages. "We just released Qt5! Good luck rewriting your code."

View on HN

If that's your goal I think you should wait a few years before starting using Rust. We have already seen early Rust code not compiling with new compiler releases. Right now we are in a move fast and break things phase.

Also, you need to be careful about what you implement yourself and what you import from crates. Otherwise it will be qt5 all over again.

> We have already seen early Rust code not compiling with new compiler releases.

Are you talking about breaking changes in the compiler after Rust 1.0? That should be very rare, and generally easy to fix (e.g. by adding a few type annotations).

Or did you use unstable features? (Not sure if embedded is usable without unstable nowadays)

It depends on your target architecture. For example, embedded development on ARM with stable Rust has been possible since 2018 (Rust 1.31)

> We have already seen early Rust code not compiling with new compiler releases.

I haven't really seen that happen with post-1.0 Rust, which is everything onwards of early 2015. I believe they've since tightened a couple of edge cases due to soundness issues, but nothing worse than that.

Would be interesting to hear about your contrary experiences.

It happened in the lexical-core crate somewhere in 1.5X. Here is a bug report I got about it with compiler errors listed: https://github.com/cortex/ripasso/issues/219

This issue is on nightly Rust, not stable. A stable Rust compiler update should never break code.

See: https://doc.rust-lang.org/book/appendix-07-nightly-rust.html

A lot of embedded stuff needs nightly. Or at least, it was like this a year or two ago.

A related issue is that for many companies "stable" means the version shipped with Ubuntu LTS.

Depends on the architecture: ARM for instance is a tier 1 target and you can use stable.

This is true for aarch64, but if you're not doing an embedded-linux style project, it's very likely you'll need nightly for inline assembly, though a significant chunk of that is being stabilized as we speak (though sadly not yet enough for my work...)

Good point. Though you can always link to .S for that last bit, right? I don't mean to tell you your business, I know you folks are doing much more intense stuff than I am. It doesn't surprise me that you'd know exactly what's keeping you from using stable.

It's all good, you're not wrong! It would just add a lot of complexity to the build for not a ton of gain...

No, it's on stable rust, maybe you got confused by the bug report talking about the nixos-unstable channel, that has nothing to do with the rust nightly builds, it's the version of nixos that is currently under development.

You can reproduce this yourself with:

  git clone https://github.com/cortex/ripasso.git
  cd ripasso
  git checkout release-0.5.1
  cargo build --locked

On my arch system this fails to build with the same errors as the bug report i got, and my rustc version is:

  $ rustc --version --verbose
  rustc 1.57.0 (f1edd0429 2021-11-29)
  binary: rustc
  commit-hash: f1edd0429582dd29cccacaf50fd134b05593bd9c
  commit-date: 2021-11-29
  host: x86_64-unknown-linux-gnu
  release: 1.57.0
  LLVM version: 13.0.0

IIRC last time we had issues it was something in the core libraries, not the compiler.

I think it was something as fundamental as Error being changed or moved around.

You may have started getting deprecation warnings because some methods in the `Error` trait have been deprecated [1] in favor of a different mechanism.

Then, you may have configured warnings to result in compilation errors in your build/project, however, I would argue this situation is not what most people would understand as "code not compiling due to a compiler update".

[1]: https://doc.rust-lang.org/std/error/trait.Error.html

In my case it failed to build, maybe it was a different problem, maybe the compiler had at some point emitted errors instead of warnings.

I don't remember and it doesn't really matter other than we had build issues and it was unexpected.

Deprecation should be the only change to Error in the last six years. It hasn’t moved. If you ever get a repro would love to hear about it! This kind of thing doesn’t happen at the scale we’re at anymore, if it did there would be an uproar.

For me, even in high level, an API should only be broken, when/if it gives a benefit over the old approach.

Sadly quite often it's only new and shiny to sell something :/

I assume in embedded this is simply different, because the needs are others.

> I need my code to build/run today and also in 10 years

I think you should stick with C if this is a hard goal. Let Rust settle for some years before going all in.

Reply on news.ycombinator.com