bastion VS rustig

How is this better / different than https://github.com/bastion-rs/bastion ?

There are attempts to implement an Erlang/BEAM-inspired reactor/runtime/executor/ecosystem for Rust's Async, in particular Bastion. (There are also Lumen, Lunatic and Async-Backplane/Async-Supervisor.)

I would be interested in an example showing how to build a robust runtime like bastion with fault tolerance.

But the issue you're referring to, building a fault-tolerant web server where you can have granular control over killing background jobs regardless if they're blocked on a syscall, totally requires using this kind of software architecture. See Bastion.

Bastion, a Rust async runtime inspired by the beam distribution and supervision model

I don't really know much about erlang, but I think this may be along the lines of what you are thinking of: https://github.com/bastion-rs/bastion

(I also don't really think the linux kernel people would be interested...)

This reminds me of bastion. Looks like it attempts to fulfill the same needs, though I guess Lunatic has native WASM support whereas bastion might require some tweaking to have it work? Haven't worked with bastion, so that part of harder time with WASM is just a wild speculation. On the other hand bastion looks much more mature. Probably /u/vertexclique could give a more informed opinion about the difference between the two ;) I really like what these projects are putting forward.

There is also rustig though it seems quite dead.

There’s the rustig tool (https://github.com/Technolution/rustig) that looks for code paths leading to the panic handler. Not sure if it still works though.

That's fair. I think I may just be a bit sore that Rustig was allowed to bit-rot and findpanics hasn't seen a commit since 2020.

There's Rustig which does it for panics, though it seems unmaintained and uses inspection of the final binary rather than source code/AST inspection.

You might be interested in this: https://github.com/Technolution/rustig

> Doesnt Rust have implicit panics on indexing out of bounds?

It does yes. A fair number of other constructs can panic as well.

> I wonder if any codebases lint those away.

Clippy has a lint for indexing so probably.

For the general case, it's almost impossible unless you're working on very low-level software (embedded, probably kernel-rust eventually) e.g. `std` assumes allocations can't fail, so any allocation will show up as a panic path.

https://github.com/Technolution/rustig can actually uncover panic paths, but because of the above the results are quite noisy, and while it's possible to uncover bugs thanks to rustig it requires pretty ridiculous amounts of filtering.

This comment is strongly confused.

> [1] https://github.com/Technolution/rustig

That's a binary analysis tool. It is only approximate, and does not claim to be an accurate analysis like unsafe-checking and typechecking are:

https://github.com/Technolution/rustig#limitations

> All paths leading to panic! from one of those functions (whether actually used or not) will be reported.

It also only works on x86_64 binaries.

Panics are an ugly leftover from the bad old days before Rust had nice monad-like syntax for Result error-handling (the "?" syntax). It's time for panic to sunset.