websocket VS go

Aria is a lightweight, event-driven WebSocket framework for Go. It is inspired by olahol/melody and built on top of coder/websocket.

As a regular Go user, I agree with this take. Though the tools exist, error wrapping and checking (with errors.Is and so on) is actually pretty rare in my experience.

Positive example of good and appropriate usage here: https://github.com/coder/websocket/blob/master/internal/exam...

Websocket

In my experience Go has been relatively approachable for people that are good at PHP. It has a great standard library and a pretty solid ecosystem, though frameworks aren’t as popular in Go. There are some well regarded libraries for things like WebRTC via https://github.com/pion/webrtc WebSicket via https://github.com/nhooyr/websocket

Also take a look at https://github.com/nhooyr/websocket - which is a good ws library, but I don't have anything specific about its memory usage per connection. But from what I see it will be somewhat similar to x/net/websocket.

nhooyr/websocket, shollz/pake, charmbracelet/bubbles, charmbracelet/bubbletea, charmbracelet/lipgloss, muesli/reflow, klauspost/pgzip and many, many more.

link: https://github.com/nhooyr/websocket

“The language is simple on purpose. If you want cleverness, write LISP.” Go issue tracker discussion

> To convert the Stream.Reader to an std.Io.Reader, we need to call its interface() method. To get a std.io.Writer from an Stream.Writer, we need the address of its &interface field. This doesn't seem particularly consistent.

That made me think of how that change would be received in Go (probably would be discarded). They way they approach changes in extremely deep analysis and taking as much time as it needs to avoid mistakes and reach a consistent solution (or as close as possible).

This has been my favorite for a while: https://github.com/golang/go/issues/45624

4 years to decide on something relatively minor, that right now can be done with a bit of a one-liner extra work. But things need to be well thoguth out. Inconsistencies are pointed out. Design concerns are raised. Actual code usage in the real world are taken into account... too slow for some people, but I think it's just as slow as it needs* to be. The final decision is shaping out to be very nice.

It is rare to encounter this in practice, and it does get picked up by the race detector. But the language designers chose not to address it, so I think it's a valid criticism. [1]

Once you know about it, though, it's easy to avoid. I do think, especially given that the CSP features of Go are downplayed nowadays, this should be addressed more prominently in the docs, with the more realistic solutions presented (atomics, mutexes).

I also think Go should add 128-bit atomic operations, which could cover strings and interfaces at least (unfortunately, slices are three words in size). It's on their radar at least [2] and there exists an external package [3].

[1]: https://research.swtch.com/gorace

[2]: https://github.com/golang/go/issues/61236

[3]: https://pkg.go.dev/github.com/CAFxX/atomic128

Sorry. Was at dinner. It's Russ Cox. Being hungry and in a hurry doesn't help with remembering names.

The GitHub discussion is there: https://github.com/golang/go/discussions/58409

but the words I of Russ I cited is here: https://groups.google.com/g/golang-dev/c/73vJrjQTU1M/m/WKj7p...

Copying verbatim:

It's good to know that's what it looks like. I can tell you that the shouting did not really influence the decision. Long-time Go contributors and supporters commenting quietly or emailing me privately had far greater influence.

A few more links that I collected recently on the topic

https://github.com/golang/go/issues/73626

https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/...

https://web.dev/articles/fetch-metadata

https://appliedgo.net/spotlight/csrf-dont-mess-with-my-site/

So now there is at least a workaround to preserve the order when processing JSON. Great!

[1] https://github.com/golang/go/issues/27179#issuecomment-22899...

Anonymous functions aren't the same as lambda functions. People in the Go community keep asking for lambda functions and never get them. There should be no need for func/fn and explicit return. Because the arrow would break stuff is one of the reasons.

See

https://github.com/golang/go/issues/59122

https://github.com/golang/go/issues/21498

I'd say it's fair to call this a footgun, though not a bug. The context is really only intended to apply to the goroutines. And Wait has to cancel the context to prevent a resource leak.

I suggest in general using function scoping to drive the lifetime of contexts, etc. This works also for defers and tracing spans in addition to the canonically shadowed `ctx` variable.

There is an old issue in the tracker proposing changes to alleviate this: https://github.com/golang/go/issues/34510. The original author (bcmills) of the errgroup package shared insight into the design choices/tradeoffs he made.

You can check the language out here!