bastion VS suture

Compare bastion vs suture and see what are their differences.

Our great sponsors
  • WorkOS - The modern identity platform for B2B SaaS
  • InfluxDB - Power Real-Time Data Analytics at Scale
  • SaaSHub - Software Alternatives and Reviews
bastion suture
15 14
2,747 1,259
0.8% -
0.0 5.7
11 months ago 21 days ago
Rust Go
Apache License 2.0 MIT License
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.

bastion

Posts with mentions or reviews of bastion. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-08-06.

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

What are some alternatives?

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

actix - Actor framework for Rust.

smol - A small and fast async runtime for Rust

lunatic - Lunatic is an Erlang-inspired runtime for WebAssembly

riker - Easily build efficient, highly concurrent and resilient applications. An Actor Framework for Rust.

tiny-tokio-actor - A simple tiny actor library on top of Tokio

rustig - A tool to detect code paths leading to Rust's panic handler

async-backplane - Simple, Erlang-inspired fault-tolerance framework for Rust Futures.

lumen - An alternative BEAM implementation, designed for WebAssembly

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

wactor - Ultra minimal actor API wrapper for lunatic

Coerce-rs - Actor runtime and distributed systems framework for Rust

async-wormhole