Roberto Selbach

I am currently trying a new approach to deal with my social phobia.

File this one under techies complaining about non-techies.

I am sad.

I installed Go 1.4 to test a service and found the most interesting changes below my source code.

I added a dial timeout to an HTTP client and assumed I had bounded the entire request.

A few years ago I wrote about how social anxiety makes me use fake accounts on the web.

I tested a locked lookup table with Go 1.3’s parallel benchmark support: func BenchmarkLookupParallel(b *testing.B) { b.RunParallel(func(pb *testing.PB) { for pb.Next() { _ = table.Lookup("troy") } }) } RunParallel creates goroutines and distrib…

Even though I’ve been playing Kerbal Space Program for over a year, I have only barely explored the outer kerbolar system.

I used Go 1.3’s new sync.Pool to reuse temporary buffers in an HTTP formatter.

About an year ago, I started a new project in a stealth startup.

One of our larger binaries spent enough time linking that I could switch windows, forget why, and begin an unrelated task.

I was reviewing a parser and found a function returning a pointer to a local variable: func parseCount(s string) (*int, error) { n, err := strconv.Atoi(s) if err !

I upgraded a memory-heavy worker to Go 1.3 expecting the garbage collector to become invisible.

After installing Go 1.3 I reran a recursive parser benchmark that had always behaved oddly at certain depths.

An HTTP service of mine usually answered in a few milliseconds but occasionally took more than 100.

I changed a formatter from a concrete parameter to an interface and expected the call to behave like a generic wrapper around the value.

I reproduced a build failure only after deleting my GOPATH.

A few days ago I posted about a new Go package called validator that we initially developed for our own internal use at project7.io but what fun is internal stuff, right?

The thing about working in a startup under stealth mode is you can’t often talk about what you’re doing.

I split a package this week because its name had become meaningless. util contained HTTP parsing, identifiers, retry logic, and one function that formatted dates.

I blamed encoding/json for an allocation spike in an API client.

I had a polling client that became steadily slower.

I wrote a small validator that accepted interface{} and walked fields marked validate:"required".

I wanted one struct to describe both its JSON name and a tiny validation rule.

On the way to the Moon, the Apollo crew and ground control needed precise information about the position, speed, and acceleration of the stack.

Three Go 1.2 additions fixed three unrelated annoyances in one week.

One of my test programs had a rude goroutine: it performed a long loop containing function calls while another goroutine waited to print progress.

I upgraded a small service to Go 1.2 and immediately found a use for the new full slice expression.

I lost an hour today to an error value that was plainly nil and just as plainly refused to compare equal to nil.

I assumed GOMAXPROCS(1) meant my program would use one operating-system thread.

I fixed a database slowdown by adding an index, then briefly credited the Go connection pool.

After the race detector found a real bug, I wanted to know whether it was merely running the program many times and hoping for an unfortunate schedule.

Go 1.1 permits a useful expression I kept trying to write before it existed: a method value. type counter struct{ n int } func (c *counter) add(n int) { c.n += n } c := &counter{} add := c.add add(3) add(4) fmt.Println(c.n) // 7 The expression c.add pr…

I had two versions of a formatter with nearly identical benchmark times.

Um amigo publicou um texto no Facebook hoje que me lembrou do MBA.

Every small text-processing program I write begins with the same lie: “I only need to read a file line by line.”

I rebuilt a little indexing program with Go 1.1 and it became faster without receiving any of my expert optimization, which is generally the safest kind.

Go 1.1’s race detector found a bug in a cache I had described as “effectively read-only.”

I liked the idea behind App.Net (or ADN for the initiated) from the start; I’ve happily signed up during the initial funding effort and before it even existed.

Go 1.1 was released this week, so naturally I ignored the pleasant surface additions and went looking for the scheduler changes.

I put sql.Open inside an HTTP handler because the function was named Open and I wanted to open the database.

I have long been a bit of a nomad.

Eight years ago I joined a great company in Intel.

I wrote an echo server with one goroutine per connection and then wondered where all the operating-system threads were.

I needed to print arbitrary structs for a debugging tool.

I wrote the concurrency equivalent of checking whether the refrigerator light is off by repeatedly opening the door: var ready bool var value string func load() { value = "finished" ready = true } func main() { go load() for !

I wanted to rename a field across a pile of Go files.

I appreciate beautiful, readable code.

One request in a test server occasionally took much longer than its neighbours.

The recently approved C++11 standard brings a lot of welcome changes to C++ that modernize the language a little bit.