High-performance JSON parsing in #golang by @CockroachDB

https://www.cockroachlabs.com/blog/high-performance-json-parsing/

Repo with some examples of concurrency patterns in Golang ->

https://github.com/lotusirous/go-concurrency-patterns

🎉 Finally 🙂
https://tip.golang.org/ref/spec#Min_and_max

print(“lol”) doubled the speed of my #golang function 😂

https://medium.com/@ludirehak/printing-lol-doubled-the-speed-of-my-go-code-e32e02fc3f92

Limit goroutines with buffered channels

https://rednafi.com/go/limit_goroutines_with_buffered_channels/

"I thought I understood how iteration over an array works but apparently not in Golang"

https://medium.com/@haaawk/i-thought-i-understood-how-iteration-over-an-array-works-but-apparently-not-in-golang-441a7abd6540

Finally we can use it without many lines of / and &&


Tl;dr:
With all that out the way, we can use a heredoc, executing two commands in the same RUN!:

RUN <<EOF
echo "Hello" >> /hello
echo "World!" >> /hello
EOF

->
https://www.docker.com/blog/introduction-to-heredocs-in-dockerfiles/

Slides of my talk from #kcdaustria about debugging #golang apps inside #k8s cluster

https://drive.google.com/file/d/1-6ERQda23o7OiLHziz4wwgvdFWS0kyv8/view

And repo with samples/Dockerfiles for try it out!

https://github.com/andriisoldatenko/debugging-containerized-go-applications

Discussion of 1BRC in Go https://github.com/gunnarmorling/1brc/discussions/67

Context: https://twitter.com/gunnarmorling posted a problem https://www.morling.dev/blog/one-billion-row-challenge/ the idea is pretty simple and from another side not so simple:

>write a Java program for retrieving temperature measurement values from a text file and calculating the min, mean, and max temperature per weather station. There’s just one caveat: the file has 1,000,000,000 rows!

Go’s CompareAndSwap is not always Compare-and-swap

>Go's standard package sync/atomics provides programmers with functions to use the underlying CPU-level atomic operations such as compare-and-swap (CAS), through atomic.CompareAndSwapT (where T is an integer type).

> Problem: Not all CPU architectures offers a CAS instruction to rely on to implement atomic.CompareAndSwapT. However, Go must compile that function code to something semantically equivalent—let's see what.

https://lu.sagebl.eu/notes/go-cas/

Hiring Challenge: Smallest #golang Websocket Client

https://dyte.io/blog/hiring-challenge-smallest-golang-websocket-client/ by @dyte_io

Collections what's new in Go 1.22:

- slices.Concat https://blog.carlana.net/post/2024/golang-slices-concat/
- reflect.TypeFor https://blog.carlana.net/post/2024/golang-reflect-type-for/
- https://pkg.go.dev/cmp#Or
- https://pkg.go.dev/net/http@master#FileServerFS
- https://pkg.go.dev/database/sql#Null

proposal: reflect: add TypeAssert likely accepted 🎉 ')

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

TIL: a % 128 = 0 is the same as a & 127 = 0

'Which is a faster operation since it just requires doing the AND and not the whole division and remainder comparison' @jesusvazquezp

from https://github.com/prometheus/prometheus/pull/14118#pullrequestreview-2068077407

How do you track code coverage for OSS projects?

codecov seems very flaky, (will provide some details in thread)

wdyt about https://github.com/vladopajic/go-test-coverage?tab=readme-ov-file

https://tip.golang.org/doc/go1.23#iterators uhhhh 🙃🙃🙃🙃

For all GO haters :) https://juli1.substack.com/p/why-i-fell-in-love-with-go

Nice quote and summary:
>Technologies like JavaScript or Go are like a good burger: it’s an option that the majority understand and choose regularly. It may not be the most elegant option, but it does the job and allows us to focus on problems that matter.