thepudds

I've spent the past couple months hand crafting a new B-tree map implementation for Go. It's fast. Faster than Rust's BTreeMap. Faster than the fastest C++ (frozenca/btree). And about 2x faster than my current Go btree (tidwall/btree).

Release v3.13.0 · mvdan/sh This release introduces support for Zsh in the parser and formatter, which was tracked in issue #120 alongside the label zsh . While support is not complete, it should be far enough for many u...

I've just released a new version of the "sh" #golang module, including initial Zsh support in shfmt, as well as many improvements and fixes to the parser and interpreter 🎉

proposal: cmd/go: only set vcs.modified=true if changes are relevant to build · Issue #77897 · golang/go Proposal Details If I run 'go build' in a repo with a random extra file that doesn't matter to the build, the runtime build info in the binary says vcs.modified=true and the main module path has a ...

Finally! No more "dirty" #golang builds because you have untracked files laying around which don't affect the build at all :)

Got an idea buzzing in that brilliant gopher brain of yours? 🧠

Don’t keep it in the lab; share it with the #golang community! 🧪

#GopherCon Call for Speakers closes March 4th.

Submit your proposal ➡️ sessionize.com/gophercon-20...

#RoadToGopherCon

(Many of the problems flagged by gopls also come from go vet, and the core Go team maintains an additional set of excellent code analyzers that are also used by gopls, but Dominik's Staticcheck is much broader than either of those.)

Small #golang PSA:

Most of the very nice automatic code problem reports in your editor or IDE come from Staticcheck by Dominik Honnef (@honnef.co).

gopls is the LSP, and it uses many of the rules from Staticcheck.

Suggestion: consider sponsoring Dominik! (Well worth it in my humble opinion😅)

I'm putting the finishing touches on the Staticcheck update for #golang 1.26. You can expect a release by the end of the week.

Some pretty awesome improvements in 1.26 for compiling/testing typescript-go.

With a clean build/test cache, running the full test suite used to take 3m45s, but now takes just 2m10s.

Go 1.26 interactive tour New with expressions, type-safe error checking, and faster everything.

Go 1.26 is out, and the announcement says:

"Over the next few weeks, follow-up blog posts will cover some of the topics in more detail. Check back later."

So you can wait a few weeks OR you can read my interactive Go 1.26 tour right away:

antonz.org/go-1-26

With Go 1.26, you can easily log to multiple targets (like stdout, a file, or a remote server) using just the standard library.

All thanks to slog.MultiHandler, which sends log records to any number of handlers you configure.

I think some @tangled.org folks are at FOSDEM if you want to talk to them about stacked reviews use case and comparison with Gerrit.

Maybe you could help ever-so-slightly nudge the industry forward on the goodness of Gerrit. 🤞

(And maybe in parallel you can nerd snipe them into using some CUE 😅)

@rog.bsky.social this sounds perfect for testing servers locally, especially with synctest 😊

github.com/golang/go/is...

This is a fun writeup of using C to implement #golang interfaces (or maybe Rust traits), complete with editable C you can run via your browser.

It pairs nicely with the classic post on the Go interface implementation by @swtch.com from 16 (!) years ago:

research.swtch.com/interfaces

“Floating-Point Printing and Parsing Can Be Simple And Fast”

The fastest known floating-point printer and parsing algorithms - fixed-width printing, shortest-width printing, and parsing, all in 400 lines of Go.

research.swtch.com/fp
research.swtch.com/fp-proof

Maybe you were thinking of this from earlier this week?

bsky.app/profile/apen...

And to be clear, that's not some backhanded complaint. 😅

I'm glad folks in academia study FOSS ecosystems, which seems like a treasure trove of interesting research questions, and they cleanly cited everything.

The two main issues I think were:

go.dev/issue/31543

go.dev/issue/32695

Hero: On the Chaos When PATH Meets Modules Ever since its first release in 2009, the Go programming language (Golang) has been well received by software communities. A major reason for its success is the powerful support of library-based devel...

There's also this 2021 paper:

arxiv.org/abs/2102.12105

It's more specific to some Go modules transition pains

(For me, reading that paper felt odd because I kept saying "huh, I recognize that example" and then slowly realized large portion of the paper was based on ~3 GitHub issues I had filed 😅)

@michael.express and @prattmic.com, you'll likely be pleased to see this 🚀

Very nice!

#golang flight recorder taking off (so to speak)

Also now on stream.place

(so might depend on how broad the definition of “here” is 😅)

A good way to keep up with the Go project is this starter pack from @mvdan.cc (long-time #golang contributor).

Two other good ways to keep up are subscribing to the Go proposal review meeting GitHub issue:
go.dev/issue/33502

and the Go compiler & runtime meeting notes issue:
go.dev/issue/43930

Integration tests are best tests Itegration tests are the most important kind of tests. You should strive for excellent integration test coverage and invest relatively little time in unit tests. I've believed this since I worked on c...

New blog post, with a perhaps mildly unpopular opinion: jayconrod.com/posts/133/in...

Large chunks of the Go ecosystem do a good job respecting semver, but some pockets don't, which I think is partly why many gophers ~never have problems upgrading but some gophers do.

In other words, it's reasonable to upgrade however works well for you (based on your project's goals, its deps, etc)

Or more precisely, it's fine to use -u as a conscious decision.

The "mistake" I've often seen is gophers not knowing -u is optional (without knowing that 'go get foo' also updates foo but doesn't force upgrade of all foo's deps past the versions foo's authors likely validated when releasing foo).

Related #golang PSA:

Gophers often mistakenly put a -u in 'go get -u foo', when they would have been better off with just 'go get foo'.

'go get foo' says to upgrade foo itself. It's shorthand for 'go get foo@upgrade'

'go get -u foo' says to *also* upgrade all the direct and indirect deps of foo.

30 Years of Programming at 44 Years Old

blainsmith.com/articles/30-...

#Programming #Birthday

Tailscale, AT protocol, #golang, holding hands running through a field

I vaguely recall a core Go team member saying that early on, they thought it worth trying out a different time formatting approach (unlike strftime or similar), but also that with hindsight they might have made different choices, including if they had known at the time how widely Go would be used. 😅

The time package documentation says:

"The calendrical calculations always assume a Gregorian calendar, with no leap seconds."

pkg.go.dev/time

The Go stdlib is large compared to some ecosystems, but more focused than some others, and it does not try to cover everything:

go.dev/doc/faq#x_in...

Go Playground - The Go Programming Language

That string is the value of the 'time.ANSIC' constant defined in the time package:

pkg.go.dev/time#pkg-con...

Here's a quick playground example showing that pattern in use, along with some other variations (including with and without an underscore in the format pattern):

go.dev/play/p/Gu7bC...