suture VS chi

This one is highly specialized, but I'm a huge fan of Suture for managing long lived goroutines.

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.

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.)

If you also want Supervisor-like behavior, take a look at suture.

For context, I've been working with similar interfaces for many years through suture.

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.

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

(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.)

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.

I use go-chi for handling routes and to server static file(stylesheet).

This will be the structure of our project, we will use PostgreSQL as the database, go chi to create our endpoints, go dot env to import our environment variables.

go-chi: is a lightweight, idiomatic and composable router for building Go HTTP services.

Go Chi para criar nossas rotas

For HTTP I'd look at Chi https://github.com/go-chi/chi

In fact, it has zero dependencies outside of std lib in it's core: https://github.com/go-chi/chi/blob/master/go.mod

Interesting. go-chi added it as a middleware 4 months ago, but its not in the module docs since they haven't tagged a version since Dec 2022: https://github.com/go-chi/chi/blob/master/middleware/request_size.go