| 2025-03-20: |
Go's choice of multiple return values was the simpler option
|
| 2025-03-19: |
Go's multiple return values and (Go) types
|
| 2025-02-24: |
Go's behavior for zero value channels and maps is partly a choice
|
| 2025-01-09: |
Realizing why Go reflection restricts what struct fields can be modified
|
| 2024-12-16: |
Some notes on "closed interfaces" in Go
|
| 2024-12-15: |
I think Go union type proposals should start with their objectives
|
| 2024-12-02: |
Good union types in Go would probably need types without a zero value
|
| 2024-12-01: |
Union types ('enum types') would be complicated in Go
|
| 2024-10-18: |
The Go module proxy and forcing Go to actually update module versions
|
| 2024-10-02: |
Go's new small language features from 1.22 and 1.23 are nice
|
| 2024-09-24: |
Go and my realization about what I'll call the 'Promises' pattern
|
| 2024-08-19: |
It's not simple to add function keyword arguments to Go
|
| 2024-07-11: |
Brute force attackers seem to switch targets rapidly if you block them
|
| 2024-06-17: |
Go's 'range over functions' iterators and avoiding iteration errors
|
| 2024-05-25: |
Reasons to not expose Go's choice of default TLS ciphers
|
| 2024-05-21: |
Go's old $GOPATH story for development and dependencies
|
| 2024-02-24: |
The Go 'range over functions' proposal and user-written container types
|
| 2024-02-14: |
Understanding a recent optimization to Go's reflect.TypeFor
|
| 2024-01-25: |
In Go, I'm going to avoid using 'any' as an actual type
|
| 2023-12-18: |
In Go, constant variables are not used for optimization
|
| 2023-12-14: |
Partially emulating #ifdef in Go with build tags and consts
|
| 2023-11-27: |
Go's API stability and making assumptions, even in semi-official code
|
| 2023-11-11: |
Go modules and the domain expiry problem
|
| 2023-11-01: |
People do change what a particular version is of a Go module
|
| 2023-05-20: |
Some notes on the cost of Go finalizers (in Go 1.20)
|
| 2023-04-10: |
Failing to build a useful pre Go 1.21 static Go toolchain on Linux
|
| 2023-01-28: |
I should assume contexts aren't retained in Go APIs
|
| 2022-12-20: |
Detecting missing or bad Go modules and module versions
|
| 2022-12-13: |
Go and the case of the half-missing import
|
| 2022-11-20: |
Floating point NaNs as map keys in Go give you weird results
|
| 2022-11-18: |
Go 1.21 may have a clear(x) builtin and there's an interesting reason why
|
| 2022-11-06: |
Go's sync.Pool has (undocumented) 'thread' locality
|
| 2022-10-19: |
Understanding '+incompatible' in Go module version names
|
| 2022-10-17: |
The proper setup of a Go module, as I understand it
|
| 2022-09-01: |
Go 1.19 added an atomic.Pointer type that's a generic type
|
| 2022-08-17: |
Some resources for looking at the current development version of Go
|
| 2022-06-25: |
A limitation on what 'go install' can install (as of Go 1.18)
|
| 2022-06-14: |
Go programs and Linux glibc versioning
|
| 2022-03-31: |
The awkward timing of Fedora and Go releases
|
| 2022-03-27: |
Some thoughts on Go's unusual approach to identifier visibility
|
| 2022-02-13: |
Go generics: the question of types made from generic types and type sets
|
| 2022-02-12: |
The 'any' confusion in Go generics between type constraints and interfaces
|
| 2022-01-09: |
I have mixed feelings about the Go time package's time formatting strings
|
| 2021-11-20: |
Why your Go programs can surprisingly be dynamically linked
|
| 2021-11-14: |
Go 1.18 will let you set the version of the "AMD64" architecture to target
|
| 2021-10-26: |
Go 1.18 will embed source version information into binaries
|
| 2021-09-24: |
Go generics have a new "type sets" way of doing type constraints
|
| 2021-09-02: |
Go multi-module workspace mode, a forthcoming feature in Go 1.18
|
| 2021-08-31: |
Go doesn't have a stack the way that some other languages do
|
| 2021-08-29: |
In Go, pointers (mostly) don't go with slices in practice
|
| 2021-08-13: |
Go keeps surprising me with its careful design and specification
|
| 2021-07-29: |
How Go maps store their values (and keys)
|
| 2021-07-23: |
Why it matters that map values are unaddressable in Go
|
| 2021-07-19: |
Making a Go program build with Go modules can be not a small change
|
| 2021-06-24: |
Go 1.17 is deprecating the traditional use of 'go get'
|
| 2021-04-21: |
Go 1.17 will allow converting a slice to an array pointer (some of the time)
|
| 2021-04-05: |
A stable Unix updating its version of Go isn't straightforward
|
| 2021-04-04: |
You need a version of Go with module support (ideally good support)
|
| 2021-03-29: |
Nil in Go is typed in theory and sort of untyped in practice
|
| 2021-03-10: |
The tradeoffs of Go version behavior in go.mod module files
|
| 2021-03-09: |
Go version directives in go.mod files: some notes and crude usage numbers
|
| 2021-01-13: |
What you can and can't build in Go's module mode
|
| 2020-12-20: |
Go modules are soon going to be the only future
|
| 2020-12-18: |
On Go, release timing, and new machines
|
| 2020-11-27: |
Setting up self-contained Go program source that uses packages
|
| 2020-10-16: |
Go is gaining the ability to trace init calls on program startup
|
| 2020-10-15: |
Go packages can have more than one init() function
|
| 2020-09-29: |
Where (and how) you limit your concurrency in Go can matter
|
| 2020-09-15: |
When the Go garbage collector will panic over bad pointer values
|
| 2020-09-01: |
Even in Go, concurrency is still not easy (with an example)
|
| 2020-08-29: |
An interesting mistake with Go's context package that I (sort of) made
|
| 2020-08-15: |
Go will inline functions across packages (under the right circumstances)
|
| 2020-07-18: |
Using Go build directives to optionally use new APIs in the standard library
|
| 2020-07-10: |
The impact on middleware of expanding APIs with Go's interface smuggling
|
| 2020-07-08: |
"Interface smuggling", a Go design pattern for expanding APIs
|
| 2020-07-05: |
A Go lesson learned: sometimes I don't want to use goroutines if possible
|
| 2020-06-21: |
In Go, the compiler needs to know the types of things when copying values
|
| 2020-06-07: |
A Go time package gotcha with parsing time strings that use named time zones
|
| 2020-06-02: |
A subtle trap when formatting Go time.Time values
|
| 2020-05-13: |
Getting my head around what things aren't comparable in Go
|
| 2020-05-04: |
The Go compiler has real improvements in new versions (and why)
|
| 2020-04-27: |
I think you should generally be using the latest version of Go
|
| 2020-03-19: |
Sorting out Go's 'for ... = range ..' and when it copies things
|
| 2020-03-02: |
More or less what versions of Go support what OpenBSD releases (as of March 2020)
|
| 2020-03-01: |
The situation with Go on OpenBSD
|
| 2020-02-29: |
OpenBSD versus Prometheus (and Go)
|
| 2020-02-28: |
One reason for Go to prefer providing indexes in for ... range loops
|
| 2020-01-24: |
Go compared to Python for small scale system administration scripts and tools
|
| 2020-01-23: |
What we've written in Go at work and how it came about (as of January 2020)
|
| 2020-01-22: |
Why I've come to like that Go's type inference is limited
|
| 2020-01-15: |
How Go's net.DialContext() stops things when the context is cancelled
|
| 2019-12-31: |
Things I've stopped using in GNU Emacs for working on Go
|
| 2019-12-25: |
Some reasons for Go to not make system calls through the standard C library
|
| 2019-12-08: |
The Go runtime scheduler's clever way of dealing with system calls
|
| 2019-11-07: |
Realizing that Go constants are always materialized into values
|
| 2019-10-20: |
A small irritation with Go's crypto/tls package
|
| 2019-09-18: |
Converting a Go pointer to an integer doesn't quite do what it looks like
|
| 2019-09-14: |
Some notes on the structure of Go binaries (primarily for ELF)
|
| 2019-09-11: |
Making your own changes to things that use Go modules
|
| 2019-09-09: |
A safety note about using (or having) go.mod inside $GOPATH in Go 1.13
|
| 2019-09-06: |
Go modules and the problem of noticing updates to dependencies
|
| 2019-08-15: |
Getting LSP-based editing working for Go in GNU Emacs
|
| 2019-08-13: |
Changes to Go and the appearance of finality
|
| 2019-07-30: |
I think it's time to explicitly set Go's $GO111MODULE environment variable
|
| 2019-07-28: |
A note on using the Go Prometheus client package to exposed labeled metrics
|
| 2019-07-16: |
Go's proposed try() will be used and that will change how code is written
|
| 2019-07-03: |
Converting a variable to a single-element slice in Go via unsafe
|
| 2019-06-09: |
Go recognizes and specially compiles some but not all infinite loops
|
| 2019-06-05: |
Go channels work best for unidirectional communication, not things with replies
|
| 2019-05-22: |
Go is Google's language, not ours
|
| 2019-05-16: |
Go has no type for types in the language
|
| 2019-05-03: |
In Go, unsafe type conversions are still garbage collection safe
|
| 2019-04-08: |
An example of a situation where Go interfaces can't substitute for generics
|
| 2019-03-08: |
Exploring how and why interior pointers in Go keep entire objects alive
|
| 2019-01-31: |
What getopt package I use for option handling in my Go programs
|
| 2018-10-06: |
A deep dive into the OS memory use of a simple Go program
Go basically never frees heap memory back to the operating system
|
| 2018-09-28: |
Addressable values in Go (and unaddressable ones too)
|
| 2018-09-27: |
Learning about Go's unaddressable values and slicing
|
| 2018-08-31: |
Link: A deep dive into the Go memory allocator
|
| 2018-08-29: |
How I recently used vendoring in Go
|
| 2018-08-14: |
Go's net package doesn't have opaque errors, just undocumented ones
|
| 2018-08-03: |
How I want to use Go's versioned modules
|
| 2018-07-25: |
One advantage of Go modules will be less mess in $HOME/go/src
|
| 2018-05-25: |
Some notes on Go's runtime.KeepAlive() function
|
| 2018-04-17: |
Go and the pragmatic problems of having a Python-like with statement
|
| 2018-04-06: |
Using Go finalizers can be a better option than not using them
|
| 2018-03-02: |
A sysadmin's perspective on Go vendoring and vgo
|
| 2018-01-18: |
Why Go cares about the difference between unsafe.Pointer and uintptr
|
| 2018-01-02: |
Some notes on relative imports and vendor/ in Go
|
| 2017-12-06: |
In practice, Go's slices are two different data structures in one
|
| 2017-12-04: |
Some notes on using Go to check and verify SSH host keys
|
| 2017-10-10: |
An interesting way to leak memory with Go slices
|
| 2017-08-27: |
Is bootstrapping Go from source faster using Go 1.9 or Go 1.8?
|
| 2017-08-23: |
Why Go changes its minimum version requirements for OSes (and hardware)
An unexpected risk of using Go is it ending support for older OS versions
|
| 2017-08-13: |
Sorting out slice mutability in Go
|
| 2017-07-06: |
Link: Survey of [floating point] Rounding Implementations in Go
|
| 2017-06-16: |
Go interfaces and automatically generated functions
|
| 2017-06-06: |
A humbling experience of misreading some simple (Go) code
|
| 2017-05-12: |
Where bootstrapping Go with a modern version of Go has gotten faster
|
| 2017-05-10: |
Building the Go compiler from source from scratch (on Unix)
|
| 2017-03-20: |
My theory on why Go's gofmt has wound up being accepted
|
| 2017-01-26: |
Things that make Go channels expensive to implement
|
| 2016-12-29: |
One reason why Go's increment and decrement statements are good to have
|
| 2016-12-08: |
Trailing text, a subtle gotcha with Go's fmt.Sscanf
|
| 2016-11-16: |
Go's arbitrary-precision constants and cross compilation
|
| 2016-10-23: |
I should keep a released version of the Go compiler suite
|
| 2016-08-19: |
My current Go autocompletion setup in GNU Emacs
|
| 2016-06-05: |
My approach for inspecting Go error values
|
| 2016-05-18: |
Go does not have atomic variables, only atomic access to variables
|
| 2016-05-16: |
A quick trick: using Go structs to create namespaces
|
| 2016-05-09: |
You can't use expvar.Func to expose a bunch of expvar types
|
| 2016-04-05: |
Some notes on Go's expvar package
|
| 2016-04-01: |
A surprise to watch out for with Go's expvar package (in expvar.Var)
|
| 2016-03-21: |
When you want non-mutating methods in Go
|
| 2016-02-16: |
Whether or not to use cgo for Go packages, illustrated in a dilemma
|
| 2015-12-14: |
Some things that force Go to call the C library for name resolution on Linux
|
| 2015-12-09: |
Goroutines, network IO streams, and the resulting synchronization problem
|
| 2015-11-15: |
I should remember that I can cast things in Go
|
| 2015-10-18: |
In Go, unsafe.Pointer is a built in type in the compiler
|
| 2015-10-16: |
Inside a Go 'terrible hack' in the reflect package
|
| 2015-09-22: |
The Go 'rolling errors' pattern, in function call form
|
| 2015-09-14: |
A caution about cgo's error returns for errno
|
| 2015-09-09: |
Some notes on my experience using Go's cgo system
|
| 2015-09-07: |
Getting gocode based autocompletion working for Go in GNU Emacs
|
| 2015-08-31: |
CGo's Go string functions explained
Turning, well copying blobs of memory into Go structures
|
| 2015-08-30: |
Getting C-compatible structs in Go with and for cgo
|
| 2015-07-02: |
Some thoughts on Go compiler directives being in source comments
|
| 2015-05-14: |
In Go, you need to always make sure that your goroutines will finish
|
| 2015-05-13: |
Go goroutines as a way to capture and hold state
|
| 2015-03-15: |
The importance of user interface, illustrated by the Go flag package
|
| 2015-01-26: |
Some notes on keeping up with Go packages and commands
|
| 2014-12-22: |
Why Go's big virtual size for 64-bit programs makes sense
|
| 2014-12-15: |
Why your 64-bit Go programs may have a huge virtual size
|
| 2014-11-26: |
Using go get alone is a bad way to keep track of interesting packages
|
| 2014-10-24: |
In Go I've given up and I'm now using standard packages
|
| 2014-10-17: |
My experience doing relatively low level X stuff in Go
|
| 2014-09-22: |
Go is mostly easy to cross-compile (with notes)
|
| 2014-09-21: |
One reason why Go can have methods on nil pointers
|
| 2014-08-18: |
The potential issue with Go's strings
|
| 2014-07-27: |
Go is still a young language
|
| 2014-07-06: |
Goroutines versus other concurrency handling options in Go
|
| 2014-07-04: |
An interesting Go concurrency bug that I inflicted on myself
|
| 2014-06-22: |
Things I like about Go
|
| 2014-06-19: |
Some notes on Go's godoc and what it formats how
|
| 2014-06-07: |
Some ways to do sleazy duck typing in Go (from a Python perspective)
|
| 2014-06-03: |
My just-used Go logging idiom and why it is in fact wrong
|
| 2014-05-30: |
In Go, sometimes a nil is not a nil
|
| 2014-05-27: |
Some things for enumerated constants in Go
|
| 2014-01-26: |
Why writing sysadmin tools in Go is getting attractive
|
| 2013-12-02: |
What Go has become for me: Python with performance
|
| 2013-11-14: |
One reason I like Go: it seems natural to avoid object churn
|
| 2013-11-11: |
Go's getopt problem
|
| 2013-05-13: |
My language irritations with Go (so far) and why I'm wrong about them
|
| 2013-04-15: |
Go's friction points for me (and a comparison to Python)
|
| 2013-03-03: |
Go: when I'd extend an interface versus making a new one
|
| 2013-02-27: |
Link: Go at Google: Language Design in the Service of Software Engineering
|
| 2013-02-21: |
Go: using type assertions to safely reach through interface types
Some notes on my first experience with Go
|
| 2013-02-10: |
A little irritating (but understandable) limitation on Go interfaces
|
| 2012-05-17: |
The Go language's problem on 32-bit machines
|
| 2010-10-24: |
Why I'm interested in Go
|
| 2010-10-23: |
My issues with Go's net package
|
| 2010-09-10: |
Go's network package and IPv6 (and my ideal version thereof)
|
| 2010-09-09: |
Go, IPv6, and single binding machines
|
| 2010-01-03: |
Go interfaces are not my sort of interfaces
|