chi

Similar vibe, but battle tested and quite popular: https://github.com/go-chi/chi

Radix Trees are (often?) used for this purpose, for example in Chi: https://github.com/go-chi/chi. Coincidentally FSTs and Radix trees share some similarities.

> I have yet to come across a go project that doesn't pull in tons of 3rd party code as well. These have Zero dependencies. It's not rare in Go land. - https://github.com/go-chi/chi 19k stars - https://github.com/julienschmidt/httprouter 16k stars - https://github.com/gorilla/mux 21k stars - https://github.com/spf13/pflag 2.6k stars - https://github.com/google/uuid 5.6k starts Many others have just a few dependencies.

The only use for me has been to put a recoverer middleware[1] to catch any unhandled panics and return HTTP 500s in my applications. [1] https://github.com/go-chi/chi/blob/master/middleware/recover...

A better answer would be some recommendations for component pieces. e.g., I will need most of the essential things in https://github.com/go-chi/chi, so why bother rolling a version myself? The same goes for things like sqlx. I'm averse to leaning on a "framework," but do find good value in targeted libraries.

You're saying that grpc and protobuf are over engineered but you're happy with Spring? gRPC and protobuf are just transport and serialization, they have nothing to do with business logic, on the other hand Spring is a heavy, bloated framework. Most Java frameworks are complicated backed by layers of abstraction and black magic. btw no framework does not mean you don't use any library, there are some good lib aka micro framework that have everything you need to build modern and decent api servers. https://github.com/go-chi/chi https://echo.labstack.com/

How I understand it is that it's up to the user to create a panic handler middleware, which is perfectly valid and what most people are doing anyway. Something like: https://github.com/go-chi/chi/blob/master/middleware/recover...

Yeah, the idiomatic (and fast) chi router does this (https://github.com/go-chi/chi#url-parameters, https://github.com/go-chi/chi/blob/v1.5.4/context.go#L10). Routing information in stored within a chi Context (https://github.com/go-chi/chi/blob/c9e87efe9691a63d6a89de8bb...) within the request context, simply because there isn't any other way of transmitting data across http handlers. Echo and Gin have their own Context structs, except instead of http.Request wrapping their Context struct, their Context struct wraps http.Request (thereby rendering it incompatible with the stdlib). It's not a far stretch to have these frameworks retrieve their Context from the http.Request. Instead of // echo Handler func(c *echo.Context) { } they could do // standard Go handler func(w http.ResponseWriter, r *http.Request) { c

It's not difficult to make a stdlib-compatible handler with bells and whistles: just stuff everything into a context and provide helper functions for retrieving those variables from the context. This is what https://pkg.go.dev/github.com/go-chi/chi#URLParam does. Echo and Gin deviate from http.Handler because they want to be frameworks and stamp their framework-specific type signatures all over your codebase.

I'm not a big fan of Echo using nonstandard context types and nonstandard function signatures for its handlers/middleware. It boxes you into making "Echo libraries" instead of "HTTP libraries". I would recommend chi for those who want something that plays nicely with the standard library: https://github.com/go-chi/chi

Alternatively, if you’re looking to create a web application but only expose it through an HTTP API, you can simply choose an HTTP router like Routerify [1] to route HTTP requests to a stateful handler and any number of middlewares. I’m coming from Go and learning backend web dev in Rust, and this crate has been a wonderful replacement for the Go library “Chi” [2]. This comes in handy when your frontend is a SPA (e.g. Vue, React) and it’s just updating state via API calls [1] https://github.com/routerify/routerify [2] https://github.com/go-chi/chi

I've had a bad experience with Gin and when asking about alternatives in a local Go meetup I was given the advice to use https://github.com/go-chi/chi or gorilla/mux.

I'd say: assume nothing has changed. Take a look at the active projects in your area of interest. A few ones: https://echo.labstack.com https://github.com/go-kit/kit Web glue frequently recommended around here: https://github.com/go-chi/chi Github pages like https://github.com/avelino/awesome-go have become a good starting point for finding interesting projects.

I really like chi[0] - I think it strikes the right balance of being small and understandable, but also solving common problems (e.g. nested routes, URL parameters, etc.). It also uses standard Go conventions, so it's very interoperable and would be easy to migrate away from, if necessary. [0]: https://github.com/go-chi/chi