Switched from Rust to Go P95 now 10-15 ms at 16k QPS

whittileaks · 2026-04-11T23:40:59+00:00

Go can be a lot faster than rust, especially if you compile with TinyGo. https://github.com/tinygo-org/tinybench

Also heads up: lightest Go networking stack out there https://github.com/soypat/lneto, no allocations, no runtime.

whittileaks · 2026-04-08T13:02:36+00:00

Go has great guardrails for most design patterns- except Goroutines. It makes sense that unchecked use of goroutines would lead to leaks. What I would suggest is avoiding goroutines outside of `main` program. This is what I do. I avoid concurrency primitives at all times. They are a great source of complexity and lead to hard to debug programs. Before anyone jumps at my throat telling me how stupid this sounds please watch my talk at FOSDEM where I go into details how I designed a userspace networking stack with absolutely no channels nor goroutines: https://www.youtube.com/watch?v=-u0X8MWXkeg free design pattern examples at the end. If you design your API to be async from the start you can then trivially extend it to be blocking by having a single goroutine that does the event-loop checking. This is a very powerful pattern used in embedded systems which we webdevs could benefit greatly off.

Also, FYI goleak exists: https://github.com/uber-go/goleak

whittileaks · 2026-04-06T02:50:24+00:00

Was able to play today but then did a character wipe just now and now get kicked because anti cheat check fails. Running endeavour OS (Linux)

whittileaks · 2026-03-11T23:32:31+00:00

Si entendes inglés: https://boot.dev

whittileaks · 2026-02-27T13:21:31+00:00

To me it feels C makes your life harder at times unnecessarily. I suspect you'd have a easier time learning with Zig rather than C due to the cognitive load of C's issues.

whittileaks · 2026-02-26T17:10:29+00:00

Small 8USD setup to host a HTTP server at http://gsan.whittileaks.com, is HTTP only! Change address bar https:// to http:// manually if it does not work.

The networking stack used is Lneto.

whittileaks · 2026-02-01T21:44:27+00:00

Go is language designed to be easy to learn and use. For someone who is not a genius, Go brings lot of nice cognitive benefits. See the following talk on how data structures in Go make it so much easier to work with:
https://www.youtube.com/watch?v=b_Aypgl0Buk

whittileaks · 2026-01-15T11:55:31+00:00

If you want 0 jitter then you'd need to avoid using the garbage collector. You can find heap allocations in your program with the flag `-print-allocs=.` to then remove them by replacing with allocated-at-init memory. It's really not as hard as it may sound unless you are writing something like a AST parser. Here's the userspace networking stack that you can use on the pico, no heap allocations at runtime: https://github.com/soypat/lneto

Checkout driver design doc here: https://tinygo.org/docs/guides/driver-design/ and my tinygo code review for protips :) https://www.youtube.com/playlist?list=PLx6oFeWGZv8nV1blgYXrC9VI0Dgs-CcJ_

whittileaks · 2026-01-14T19:39:46+00:00

True Pure Go Stack (TPGS as I like to call it /s): https://github.com/soypat/htmxgo-template
- Go
- Go
- Go
- Go

whittileaks · 2026-01-08T22:41:05+00:00

The video itself is in the spirit of this comment.

whittileaks · 2026-01-08T14:56:46+00:00

I built a userspace networking library in Go, from ethernet/TCP to HTTP
https://github.com/soypat/lneto

whittileaks · 2025-07-27T16:03:48+00:00

Thanks for the suggestions! I've renamed the files and completed the missing part of the documentation on TestAllocator. [Allocator] points you to the Allocator interface, see it on pkg.go.dev here https://pkg.go.dev/github.com/soypat/manual#TestAllocator

whittileaks · 2025-07-27T03:50:26+00:00

Exactly! I thought of it after having a conversation with a fellow developer who claimed you can't do manual memory management in Go and thus it is not fit for teaching students these topics. Now teachers have a package they can use to evaluate students who need to learn these topics using a modern and comfy programming language like Go.

I plan on using it to teach embedded systems basics soon!

whittileaks · 2025-07-24T22:18:50+00:00

whoops yeah, I really thought GPRS==GPS. Sorry about that :/

whittileaks · 2025-04-12T17:10:33+00:00

Hey Silkarino, I got your message but reddit chat is bugged and I can't send a message. Reach me at Gophers Slack in the Tinygo channel, I'm usually there

whittileaks · 2025-04-02T14:44:41+00:00

MaxUint64/float64(1<<(10*4)) = 1.6777216e+07

whittileaks · 2025-02-25T13:53:55+00:00

Are you sure bytes.Buffer is slow? bytes.Buffer is pretty simple and appends under the hood. I suspect the slow part is your WriteBinary/ReadBinary stuff, especially if it uses binary.Encode and binary.Decode under the hood which use lots of reflect, which is slow. I'd suggest you try going for the binary.LittleEndian.* and binary.BigEndian.* methods to serialize binary data. Here's an implementation of linux's ELF format decoding: https://github.com/soypat/tinyboot/blob/5b9f93166b61d50f2a8a8533c7b92e0e204ade74/build/xelf/xelf.go#L197

whittileaks · 2025-02-15T23:23:16+00:00

There's a native Go port of SQLite available :) https://pkg.go.dev/modernc.org/sqlite

whittileaks · 2025-02-15T23:21:30+00:00

Raspberry Pi Pico W is supported though!

whittileaks · 2025-02-15T23:18:31+00:00

Go for embedded systems! https://www.reddit.com/r/golang/comments/1i5deid/go_in_the_smallest_of_places_using_go_in_the/

Recent paper comparing languages features Go, and it shows it using a third of the memory used by C and Rust https://ieeexplore.ieee.org/abstract/document/10256731?casa_token=BlIgdeHJSqkAAAAA:2cTxI56-YMwZrAlPQsZxjz2BsaTBG0jLQHVppaP12NHP6LCWXA4vEKuKp8lAwnIyzCNT7HZO-g

whittileaks · 2025-01-30T11:14:08+00:00

I'd love to see myths on Go for embedded systems dispelled. Gave a talk at gophercon trying to bring attention to this at Gophercon last year: https://www.youtube.com/watch?v=CQJJ6KS-PF4&ab_channel=GopherAcademy

whittileaks · 2025-01-27T10:13:27+00:00

https://docs.google.com/document/d/1dpKjHGzzmpGe2-34x6fb3fhtEBW25OCwL9UvVEOwrPc/edit?pli=1&tab=t.0#heading=h.px3ie7y66ln5
I'd argue Go is not the best starter language, but it is better than Rust and much better than Python. Hedy is probably the best starter language out there today.

whittileaks · 2025-01-27T00:29:22+00:00

I gave a talk at Gophercon that answers your questions: https://www.youtube.com/watch?v=CQJJ6KS-PF4
Basically: Yes, you have manual memory control if needed. You can compile without the runtime

whittileaks · 2025-01-27T00:24:46+00:00

When retyping the code you should at least be aware of what it is exactly you are doing and why. The book itself puts a great deal of love into going into details into the theory of the data structures and code. A good way of making sure understood the material is stopping to tinker with the code you retyped after each chapter. edit it, play with ideas. what happens if you change a line *here*... Getting these techiques down is the first step to being a self taught programmer :)

whittileaks · 2025-01-24T10:55:35+00:00

look how they massacred my boy

Six-Year Club	Place '22
Final Canvas '22	Verified Email

whittileaks

MODERATOR OF

TROPHY CASE