suture VS rustig

Compare suture vs rustig and see what are their differences.

suture

Supervisor trees for Go. (by thejerf)

rustig

A tool to detect code paths leading to Rust's panic handler (by Technolution)
Our great sponsors
  • WorkOS - The modern identity platform for B2B SaaS
  • InfluxDB - Power Real-Time Data Analytics at Scale
  • SaaSHub - Software Alternatives and Reviews
suture rustig
14 9
1,259 215
- 0.0%
5.7 0.0
21 days ago over 2 years ago
Go Rust
MIT License Apache License 2.0
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.

suture

Posts with mentions or reviews of suture. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-06-01.
  • Could I get a code review?
    11 projects | /r/golang | 1 Jun 2023
    This one is highly specialized, but I'm a huge fan of Suture for managing long lived goroutines.
  • [gopulse/pulse] the Golang framework designed to ensure your web services stay alive.
    3 projects | /r/golang | 17 Apr 2023
    In English, your phrasing doesn't come off as a play on words/a reference to the name, so much as it describes a feature of the library. The expectation is, with the description you've given it, the library would handle some form of resilience in service management. I half expected the library to be similar to Suture.
  • Ergo: Erlang/OTP Implemented in Golang
    3 projects | news.ycombinator.com | 28 Jan 2023
    It does not give you a way to reliably track arbitrary goroutines that "this" goroutine (for whatever that may be) wants to track, the way an Erlang process can just "link" to anything it is capable of naming the PID for.

    However, you can construct a reliable mechanism where one goroutine can start another and know whether or not the one it started has failed by using the available primitives, as I did in https://github.com/thejerf/suture . It's an easier problem since there's no cluster and no network that can get in the way. I've also done the exercise for the network case: https://pkg.go.dev/github.com/thejerf/reign#Address.OnCloseN... but that only functions within the network defined by that library because, again, it just isn't arbitrarily possible.

    (I suppose it's relevant to some of my other comments to point out that I've also implemented basically Erlang-style concurrency in Go, with network, but as a relatively idiomatic translation rather than a blind one.)

  • Is there an equivalent to Elixir / GenServer in Go? Trying to create the same request / response pattern with better performance but not sure where to start.
    2 projects | /r/golang | 23 Jan 2023
    If you also want Supervisor-like behavior, take a look at suture.
  • Erlang vs Golang
    2 projects | /r/golang | 13 Nov 2022
    I wrote suture for idiomatically-ported supervisor trees (that is, the ways they differ are deliberately chosen, not accidents), and reign for Go-native cluster-like support. I use suture in almost everything I write. Reign is used on production services but I don't generally use it because I think modern stacks have better options with modern message busses, but it can be useful for porting.
  • How “let it fail” leads to simpler code
    3 projects | news.ycombinator.com | 13 Jul 2022
    I think the distinction between expected and unexpected errors can easily fall through the cracks and writing code in a way that an unexpected error doesn’t break everything is quite powerful.

    Golang makes it easy to ignore errors that can be ignored and defer/recover provide a way to implement a way to “let it fail”

    There’s even an implementation of supervisor trees for Go [0] :)

    [0] https://github.com/thejerf/suture

  • Golang vs Elixir protoactor supervision
    2 projects | /r/golang | 26 Jun 2022
    (If you'd like something lighter weight, suture is a supervisor library without a whole lot of other stuff. If you want that other stuff, by all means, go to town.)
  • The method to manage multiple services in a process.
    2 projects | /r/golang | 17 Apr 2022
    This is the primary reason almost every program I write ends up using suture. The restarting is nice when it works, but Go code is often reasonably robust. (Not 100%, but reasonably.) But it's a nice organization principle.
  • Actor Model implementation with Go 1.18 Generics
    2 projects | /r/golang | 9 Feb 2022
  • Linus Torvalds on Rust support in kernel
    6 projects | news.ycombinator.com | 16 Apr 2021
    That is a good idea, but one thing I would advise, having both seen several attempts made at this sort of thing and having made one myself [1], try very hard to separate the accidental things Erlang brings to the idea from the fundamental things Erlang brings to the idea. Most attempts I've seen made at this flounder on this pretty hard by trying to port too-directly the exact Erlang supervisor tree idea while grinding hard against the rest of the language, rather than porting the core functionality in in a way that integrates natively with the language in question as much as possible.

    For instance, one thing I found when I was writing my library that will probably apply to most other languages (probably including Rust) is that Erlang has a somewhat complicated setup step for running a gen_server, with an explicit setup call, a separate execution call, several bits and pieces for 'officially' communicating with a gen_server, etc. But a lot of these things are for dealing with the exact ways that Erlang interacts with processes, and you probably don't need most of them. Simply asking for a process that makes the subprocess "start" from scratch is probably enough, and letting that process use existing communication mechanisms already in the language rather than trying to directly port the Erlang stuff. Similarly, I found no value in trying to provide direct ports of all the different types of gen_server, which aren't so much about the supervision trees (even if that's where they seem to be located) as a set of standard APIs for working with those various things. They're superfluous in a language that already has other solutions for those problems.

    In addition to keeping an eye out for features you don't need from Erlang, keep an eye out for features in the host language that may be useful; e.g., the most recent suture integrates with the Go ecosystem's ever-increasing use of context.Contexts as a way to manage termination, which hasn't got a clear Erlang equivalent. (Linking to processes has some overlapping functionality but isn't exactly the same, both offering some additional functionality contexts don't have as well as missing some functionality contexts do have.)

    Erlang has a lot of good ideas that I'd love to see ported into more languages. But a lot of attempts to do so flounder on these issues, creating libraries so foreign to the host language that they have zero chance of uptake.

    The other thing I'd point out is that even in Go, to say nothing of Rust, crashing is actually fairly uncommon by Erlang standards. Many things that crash in Erlang are statically prevented at compile time in Go, and Rust statically precludes even more of them. However, I have found it OTP-esque supervision trees to be a very nice organizational structure to my code; I use suture in nearly every non-trivial Go program I write because it makes for a really nice modular approach for the question of "how do I start and stop persistent services?". I have seen it hold together runtime services that would otherwise be failing, the way it is supposed to, and that's nice, but the organization structure is still probably the larger benefit.

    (There is deep reason for the way Erlang is doing it the way it does, which is that a lot of Erlang's type system, or lack thereof, is for communicating between nodes, so even if you perfectly program Erlang, if two nodes running different versions of code try to communicate with each other and they've changed the protocol you might get a pattern matching fail on the messages flowing between versions. The Erlang way of doing cross-machine communication has not caught on and this problem is handled in other ways nowadays.)

    [1]: https://github.com/thejerf/suture

rustig

Posts with mentions or reviews of rustig. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-03-25.
  • Is there something like "super-safe" rust?
    8 projects | /r/rust | 25 Mar 2023
    There is also rustig though it seems quite dead.
  • Is Rust really safe? How to identify functions that can potentially cause panic
    6 projects | /r/rust | 12 Mar 2023
    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.
  • My thoughts on Rust and C++
    7 projects | /r/rust | 20 Sep 2022
    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.
  • What improvements would you like to see in Rust or what design choices do you wish were reconsidered?
    5 projects | /r/rust | 1 Sep 2022
  • Things I hate about Rust, redux
    5 projects | /r/programming | 10 Mar 2022
    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.
    7 projects | /r/rust | 10 Mar 2022
    You might be interested in this: https://github.com/Technolution/rustig
  • Three Things Go Needs More Than Generics
    7 projects | news.ycombinator.com | 3 Oct 2021
    > 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.

  • Linus Torvalds on Rust support in kernel
    6 projects | news.ycombinator.com | 16 Apr 2021
    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.

    6 projects | news.ycombinator.com | 16 Apr 2021
    This comment is strongly missinformed:

    1- panicking allocations are here to stay, because in lots of case, it's the most convenient behavior. BUT Rust is adding fallible allocations methods (prefixed with try_) which return a result instead of panicking in allocation failure.

    2- panics are catch-able as long as you don't compile your binary with panic=abort setting (and as long as you don't panic in your panic handler itself)

    3- panics can only occur in specific places (array indexing, allocations, utf-8 validation, unwrap, etc.) which are by definition known at compile-time, and there's tooling to catch these up [1].

    In practice, a might_panic annotation would add a lot of noise for pretty much everybody, because most of us mortals use panicking function all days and it's not a big deal. Obviously it is critical for Linux, but because it's relevant only to the minority of rust users, it doesn't make sense to include it in rustc itself: it's exactly the kind of situation where external tooling is the good option.

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

What are some alternatives?

When comparing suture and rustig you can also consider the following projects:

Rust-for-Linux - Adding support for the Rust language to the Linux kernel.

go101 - An up-to-date (unofficial) knowledge base for Go programming self learning

bastion - Highly-available Distributed Fault-tolerant Runtime

pwninit - pwninit - automate starting binary exploit challenges

kani - Kani Rust Verifier

gdbstub - An ergonomic, featureful, and easy-to-integrate implementation of the GDB Remote Serial Protocol in Rust (with no-compromises #![no_std] support)

go - The Go programming language

prusti-dev - A static verifier for Rust, based on the Viper verification infrastructure.

macro_railroad_ext - Display syntax-diagrams for Rust-macros on docs.rs and doc.rust-lang.org

x_do.cr - Crystal bindings for libxdo (xdotool)

protoactor-go - Proto Actor - Ultra fast distributed actors for Go, C# and Java/Kotlin

rust - Empowering everyone to build reliable and efficient software.