Dependabot security alerts have terrible signal-to-noise ratio, especially for Go vulns. That hurts security!
Just turn it off and set up a pair of scheduled GitHub Actions, one running govulncheck and the other running CI with the latest version of your deps.
Less work, less risk, better results!
“Using go fix to modernize Go code” by Alan Donovan — https://go.dev/blog/gofix
#golang
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.
What if I told you that the building the torment nexus is an extremely interesting challenge from an engineering perspective
we all use “luddite” these days to describe someone who is reflexively anti-technology. but the original luddites were specifically against technology eliminating jobs and reducing pay in exchange for cheaper, inferior goods
Ian Lance Taylor deserves an award for the most patient person in Open Source.
He also has an amazing ability to translate the clarity of his thinking into the written word.
He has had such impact on the way people create software.
I really hope he continues to contribute to Go.
New experimental garbage collector for Go programs! github.com/golang/go/is...
This wouldn't have happened with C strings :P
![type Cache[K, V any] struct {
m sync.Map
}
// Get returns the result of new.
//
// If Get was called on k before and didn't return an error, Get will return the
// same value it returned from the previous call.
//
// If Get is called concurrently on the same k value, new might get called
// multiple times. All calls will return the same value or an error from new.
//
// The cache is evicted some time after k becomes unreachable.
func (c *Cache[K, V]) Get(k *K, new func() (*V, error)) (*V, error) {
p := weak.Make(k)
if cached, ok := c.m.Load(p); ok {
return cached.(*V), nil
}
v, err := new()
if err != nil {
return nil, err
}
if cached, loaded := c.m.LoadOrStore(p, v); loaded {
// We lost the race, return the cached value and discard ours.
return cached.(*V), nil
}
runtime.AddCleanup(k, c.evict, p)
return v, nil
}
func (c *Cache[K, V]) evict(p weak.Pointer[K]) {
c.m.Delete(p)
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:x2nsupeeo52oznrmplwapppl/bafkreieim4wanlcu5wlb34hzkw7xdhyihsx3buwtltvtnv2g3xqtngdgyu)
type Cache[K, V any] struct { m sync.Map } // Get returns the result of new. // // If Get was called on k before and didn't return an error, Get will return the // same value it returned from the previous call. // // If Get is called concurrently on the same k value, new might get called // multiple times. All calls will return the same value or an error from new. // // The cache is evicted some time after k becomes unreachable. func (c *Cache[K, V]) Get(k *K, new func() (*V, error)) (*V, error) { p := weak.Make(k) if cached, ok := c.m.Load(p); ok { return cached.(*V), nil } v, err := new() if err != nil { return nil, err } if cached, loaded := c.m.LoadOrStore(p, v); loaded { // We lost the race, return the cached value and discard ours. return cached.(*V), nil } runtime.AddCleanup(k, c.evict, p) return v, nil } func (c *Cache[K, V]) evict(p weak.Pointer[K]) { c.m.Delete(p) }
weak.Pointer (Go 1.24+), runtime.AddCleanup (Go 1.24+), and sync.Map combine wonderfully into a 20-lines weak map. #golang
It associates values to keys, with automatic garbage collection once the key becomes unreachable. Using it to tie precomputed FIPS keys to PrivateKey values we can't modify.
If your app dispays text that can't be interacted with as text, I hate you with every fiber of my being.
Programming with the help of an AI-powered coding assistant (like GitHub Copilot) is akin to pair programming with someone eager to impress, not particularly bright, and who won't shut up. Count me out. 🙅
Terminals or at least "ttys" are not modern. They are a chimera merging disparate properties of VGA, HDLC, and good old teletypes. I know I'm in the minority and always have been, but to me they are an anchor holding us back in our tech lives.
Your phone does not have a terminal.
me: i only write for my own enjoyment
me writing:
Merry Christmas to investors who have sank billions of dollars into AI products. This is truly world-changing stuff.
"Can you write this complex data transformation script to hit several different APIs and generate this really particular csv?"
Sure
"Can you automatically import it into a Google sheet?"
Never going to happen, literally impossible
@leejarvis.me Thanks mate!
Using generics and iterators in #golang feels like they've always been here. Just like I struggle to remember what I even did before modules.
Since I haven't been writing code full time professionally, I sometimes worry that I've lost a step.
Then someone comments about how they don't like #golang at a wedding reception and I instinctively reply "Oh yea? What do you use? Rust? Fuck off." and I know I've still got it.
In 2022, I left Google in search of a sustainable approach to open source maintenance. A year later, I was a full-time independent maintainer.
Today I’m announcing the natural progression of that experiment: Geomys, a small firm of professional maintainers with a portfolio of critical Go projects.
I have some exciting news on the professional open source maintainer front! 👀 ✨ 🥁
Announcing it on Monday to Maintainer Dispatches (filippo.io/newsletter) and at GopherCon Chicago.
