Roberto Selbach

One benchmark had a strange cliff: adding an innocent-looking local array made a short recursive walk much slower.

Have you ever wondered how FORs impact your code?

I changed a small parser to reuse a helper and made it slower.

My Macbook Pro has two disks, an HDD and an SSD, each of 240GB or so.

I have a little confession to make: our family is going through a rough patch.

A couple of days ago, I was listening to one of my favourite podcasts, The Frequency, when one of the hosts, Dan Benjamin, thought of a cool domain name, ohitson.com and checked to see if it was available.

I was timing a small word counter and noticed that making the map with a rough size helped more than I expected. func count(words []string) map[string]int { m := make(map[string]int, len(words)) for _, word := range words { m[word]++ } return m } Of

Last night, as I tried getting my three year-old to sleep so I could play my brand-new copy of NHL 13, I had an epiphany of sorts.

Two rows in a parser changed at once.

I lost half an hour today to an interface that was not nil even though the pointer I had put in it most certainly was.

I wrapped a C checksum function and called it once per 32-byte record.

I got myself an app.net account (@robteix) a couple of days ago.

I graphed request times for a Go 1 service and found narrow spikes hiding behind a good average.

I launched one hundred thousand sleeping goroutines and expected memory use to resemble one hundred thousand operating-system threads.

I passed a slice to a helper, changed an element, and watched the caller’s data change.

I rebuilt a March programme with a newer Go checkout today and it compiled unchanged.

I set GOPATH to the directory containing one package and then wondered why go install produced a peculiar path.

Go 1 was released yesterday, so I took a small command-line programme out of its old build script and built it using only the new go command.

I moved a test package this morning and expected to edit a build script.

I updated a retry loop for the Go 1 preview and discovered that most of my old time code was really unit conversion wearing a wristwatch.

I migrated a small text indexer to the Go 1 preview this week.

I rebuilt three small programmes against a recent weekly snapshot today.

I ran gofix over an older utility and was rewarded with a clean build.

I noticed a small server pausing at intervals under an allocation-heavy test.

The Go 1 plan changed how I looked at a compiler error today.

I wrote a small fan-out test and expected twice as many goroutines to mean twice as much parallel work.

Conspiracy theories and hoaxes abound when it comes to mankind’s arrival at our moon (or the non-arrival.)

I blamed the garbage collector for a slow parser this week.

I reached for reflection after writing the same diagnostic print twice.

Much has been said about the pros and cons of anonymity lately, prompted by Google+ TOS which require the use of one’s real name.

While I was ranting about the annoyances I found in OS X Lion today, a friend commented he had no issues at all, except for the full-screen mode.

Fascinating TEDx talk about the near future of space exploration.

I wrapped a C function that opens a file.

I’ve been spending an insalubrious amount of time on Google +.

I’ve got many gripes with the internet, I’ll admit.

I wanted to test a function that wrote a report without letting the test create files.

This weekend I took the family to celebrate Father’s Day away from town.

For fun I picked one of the Euler algorithms I had played with before and rewrote it in Go.

Just so I have it documented somewhere for future reference, here’s how to quickly set GNU Emacs up on Windows.

I rebuilt Go this morning because a small program stopped compiling after I pulled the latest sources.

Scheduler discussions become folklore quickly, so I built a few experiments that force observable events instead of inferring everything from total runtime.

My programs often begin with three configuration fields and end with a parser that believes it is a database.

Go has both ordinary failure values and panic, which guarantees that programmers will eventually use one where the other belongs.

I translated a matrix filter from C to Go and then spent an afternoon optimizing arithmetic that was not the main cost.

I ported the non-visual half of a Qt utility to Go and immediately missed signals and slots.

I had several sorted result files and wanted one sorted stream without loading everything into memory.

I ran two independent CPU loops in goroutines and expected my dual-core machine to halve the time.

Kernel code contains algorithms that look unnecessarily peculiar until the constraints are visible.

Coming from C, I first read a Go slice as a pointer with nicer indexing.

I wanted a diagnostic printer for configuration structures and reached for reflection.